// @generated by tools/generate_from_go.py; DO NOT EDIT.
// Source: D:/Works/palpo-im/references/oapi-sdk-go/service/**/resource.go
#![allow(clippy::all)]
#![allow(dead_code)]

use crate::client::{Client, OperationBuilder};
use crate::generated::ops;

pub mod acs {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod access_record {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::acs::v1::access_record::LIST);
                op
            }
        }

        pub mod access_record_access_photo {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                access_record_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::acs::v1::access_record_access_photo::GET);
                let op = op.path_param("access_record_id", access_record_id.into());
                op
            }
        }

        pub mod device {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::acs::v1::device::LIST);
                op
            }
        }

        pub mod rule_external {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::acs::v1::rule_external::CREATE);
                op
            }

            pub fn delete<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::acs::v1::rule_external::DELETE);
                op
            }

            pub fn device_bind<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::acs::v1::rule_external::DEVICE_BIND);
                op
            }

            pub fn get<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::acs::v1::rule_external::GET);
                op
            }
        }

        pub mod user {
            use super::*;
            pub fn get<'a>(client: &'a Client, user_id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::acs::v1::user::GET);
                let op = op.path_param("user_id", user_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::acs::v1::user::LIST);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                user_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::acs::v1::user::PATCH);
                let op = op.path_param("user_id", user_id.into());
                op
            }
        }

        pub mod user_face {
            use super::*;
            pub fn get<'a>(client: &'a Client, user_id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::acs::v1::user_face::GET);
                let op = op.path_param("user_id", user_id.into());
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                user_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::acs::v1::user_face::UPDATE);
                let op = op.path_param("user_id", user_id.into());
                op
            }
        }

        pub mod visitor {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::acs::v1::visitor::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                visitor_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::acs::v1::visitor::DELETE);
                let op = op.path_param("visitor_id", visitor_id.into());
                op
            }
        }
    }
}

pub mod admin {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod admin_dept_stat {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::admin::v1::admin_dept_stat::LIST);
                op
            }
        }

        pub mod admin_user_stat {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::admin::v1::admin_user_stat::LIST);
                op
            }
        }

        pub mod audit_info {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::admin::v1::audit_info::LIST);
                op
            }
        }

        pub mod badge {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::admin::v1::badge::CREATE);
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                badge_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::admin::v1::badge::GET);
                let op = op.path_param("badge_id", badge_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::admin::v1::badge::LIST);
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                badge_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::admin::v1::badge::UPDATE);
                let op = op.path_param("badge_id", badge_id.into());
                op
            }
        }

        pub mod badge_grant {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                badge_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::admin::v1::badge_grant::CREATE);
                let op = op.path_param("badge_id", badge_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                badge_id: impl Into<String>,
                grant_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::admin::v1::badge_grant::DELETE);
                let op = op
                    .path_param("badge_id", badge_id.into())
                    .path_param("grant_id", grant_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                badge_id: impl Into<String>,
                grant_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::admin::v1::badge_grant::GET);
                let op = op
                    .path_param("badge_id", badge_id.into())
                    .path_param("grant_id", grant_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                badge_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::admin::v1::badge_grant::LIST);
                let op = op.path_param("badge_id", badge_id.into());
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                badge_id: impl Into<String>,
                grant_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::admin::v1::badge_grant::UPDATE);
                let op = op
                    .path_param("badge_id", badge_id.into())
                    .path_param("grant_id", grant_id.into());
                op
            }
        }

        pub mod badge_image {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::admin::v1::badge_image::CREATE);
                op
            }
        }

        pub mod password {
            use super::*;
            pub fn reset<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::admin::v1::password::RESET);
                op
            }
        }
    }
}

pub mod aily {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod aily_session {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::aily::v1::aily_session::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                aily_session_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::aily::v1::aily_session::DELETE);
                let op = op.path_param("aily_session_id", aily_session_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                aily_session_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::aily::v1::aily_session::GET);
                let op = op.path_param("aily_session_id", aily_session_id.into());
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                aily_session_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::aily::v1::aily_session::UPDATE);
                let op = op.path_param("aily_session_id", aily_session_id.into());
                op
            }
        }

        pub mod aily_session_aily_message {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                aily_session_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::aily::v1::aily_session_aily_message::CREATE);
                let op = op.path_param("aily_session_id", aily_session_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                aily_session_id: impl Into<String>,
                aily_message_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::aily::v1::aily_session_aily_message::GET);
                let op = op
                    .path_param("aily_session_id", aily_session_id.into())
                    .path_param("aily_message_id", aily_message_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                aily_session_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::aily::v1::aily_session_aily_message::LIST);
                let op = op.path_param("aily_session_id", aily_session_id.into());
                op
            }
        }

        pub mod aily_session_run {
            use super::*;
            pub fn cancel<'a>(
                client: &'a Client,
                aily_session_id: impl Into<String>,
                run_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::aily::v1::aily_session_run::CANCEL);
                let op = op
                    .path_param("aily_session_id", aily_session_id.into())
                    .path_param("run_id", run_id.into());
                op
            }

            pub fn create<'a>(
                client: &'a Client,
                aily_session_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::aily::v1::aily_session_run::CREATE);
                let op = op.path_param("aily_session_id", aily_session_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                aily_session_id: impl Into<String>,
                run_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::aily::v1::aily_session_run::GET);
                let op = op
                    .path_param("aily_session_id", aily_session_id.into())
                    .path_param("run_id", run_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                aily_session_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::aily::v1::aily_session_run::LIST);
                let op = op.path_param("aily_session_id", aily_session_id.into());
                op
            }
        }

        pub mod app_data_asset {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                app_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::aily::v1::app_data_asset::CREATE);
                let op = op.path_param("app_id", app_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                app_id: impl Into<String>,
                data_asset_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::aily::v1::app_data_asset::DELETE);
                let op = op
                    .path_param("app_id", app_id.into())
                    .path_param("data_asset_id", data_asset_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                app_id: impl Into<String>,
                data_asset_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::aily::v1::app_data_asset::GET);
                let op = op
                    .path_param("app_id", app_id.into())
                    .path_param("data_asset_id", data_asset_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client, app_id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::aily::v1::app_data_asset::LIST);
                let op = op.path_param("app_id", app_id.into());
                op
            }

            pub fn upload_file<'a>(
                client: &'a Client,
                app_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::aily::v1::app_data_asset::UPLOAD_FILE);
                let op = op.path_param("app_id", app_id.into());
                op
            }
        }

        pub mod app_data_asset_tag {
            use super::*;
            pub fn list<'a>(client: &'a Client, app_id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::aily::v1::app_data_asset_tag::LIST);
                let op = op.path_param("app_id", app_id.into());
                op
            }
        }

        pub mod app_knowledge {
            use super::*;
            pub fn ask<'a>(client: &'a Client, app_id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::aily::v1::app_knowledge::ASK);
                let op = op.path_param("app_id", app_id.into());
                op
            }
        }

        pub mod app_skill {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                app_id: impl Into<String>,
                skill_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::aily::v1::app_skill::GET);
                let op = op
                    .path_param("app_id", app_id.into())
                    .path_param("skill_id", skill_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client, app_id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::aily::v1::app_skill::LIST);
                let op = op.path_param("app_id", app_id.into());
                op
            }

            pub fn start<'a>(
                client: &'a Client,
                app_id: impl Into<String>,
                skill_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::aily::v1::app_skill::START);
                let op = op
                    .path_param("app_id", app_id.into())
                    .path_param("skill_id", skill_id.into());
                op
            }
        }
    }
}

pub mod apaas {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod app {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::app::LIST);
                op
            }
        }

        pub mod application_audit_log {
            use super::*;
            pub fn audit_log_list<'a>(
                client: &'a Client,
                namespace: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::application_audit_log::AUDIT_LOG_LIST);
                let op = op.path_param("namespace", namespace.into());
                op
            }

            pub fn data_change_log_detail<'a>(
                client: &'a Client,
                namespace: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op =
                    client.operation(ops::apaas::v1::application_audit_log::DATA_CHANGE_LOG_DETAIL);
                let op = op.path_param("namespace", namespace.into());
                op
            }

            pub fn data_change_logs_list<'a>(
                client: &'a Client,
                namespace: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op =
                    client.operation(ops::apaas::v1::application_audit_log::DATA_CHANGE_LOGS_LIST);
                let op = op.path_param("namespace", namespace.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                namespace: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::application_audit_log::GET);
                let op = op.path_param("namespace", namespace.into());
                op
            }
        }

        pub mod application_environment_variable {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                namespace: impl Into<String>,
                environment_variable_api_name: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::application_environment_variable::GET);
                let op = op.path_param("namespace", namespace.into()).path_param(
                    "environment_variable_api_name",
                    environment_variable_api_name.into(),
                );
                op
            }

            pub fn query<'a>(
                client: &'a Client,
                namespace: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::application_environment_variable::QUERY);
                let op = op.path_param("namespace", namespace.into());
                op
            }
        }

        pub mod application_flow {
            use super::*;
            pub fn execute<'a>(
                client: &'a Client,
                namespace: impl Into<String>,
                flow_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::application_flow::EXECUTE);
                let op = op
                    .path_param("namespace", namespace.into())
                    .path_param("flow_id", flow_id.into());
                op
            }
        }

        pub mod application_function {
            use super::*;
            pub fn invoke<'a>(
                client: &'a Client,
                namespace: impl Into<String>,
                function_api_name: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::application_function::INVOKE);
                let op = op
                    .path_param("namespace", namespace.into())
                    .path_param("function_api_name", function_api_name.into());
                op
            }
        }

        pub mod application_object {
            use super::*;
            pub fn oql_query<'a>(
                client: &'a Client,
                namespace: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::application_object::OQL_QUERY);
                let op = op.path_param("namespace", namespace.into());
                op
            }

            pub fn search<'a>(
                client: &'a Client,
                namespace: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::application_object::SEARCH);
                let op = op.path_param("namespace", namespace.into());
                op
            }
        }

        pub mod application_object_record {
            use super::*;
            pub fn batch_create<'a>(
                client: &'a Client,
                namespace: impl Into<String>,
                object_api_name: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::application_object_record::BATCH_CREATE);
                let op = op
                    .path_param("namespace", namespace.into())
                    .path_param("object_api_name", object_api_name.into());
                op
            }

            pub fn batch_delete<'a>(
                client: &'a Client,
                namespace: impl Into<String>,
                object_api_name: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::application_object_record::BATCH_DELETE);
                let op = op
                    .path_param("namespace", namespace.into())
                    .path_param("object_api_name", object_api_name.into());
                op
            }

            pub fn batch_query<'a>(
                client: &'a Client,
                namespace: impl Into<String>,
                object_api_name: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::application_object_record::BATCH_QUERY);
                let op = op
                    .path_param("namespace", namespace.into())
                    .path_param("object_api_name", object_api_name.into());
                op
            }

            pub fn batch_update<'a>(
                client: &'a Client,
                namespace: impl Into<String>,
                object_api_name: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::application_object_record::BATCH_UPDATE);
                let op = op
                    .path_param("namespace", namespace.into())
                    .path_param("object_api_name", object_api_name.into());
                op
            }

            pub fn create<'a>(
                client: &'a Client,
                namespace: impl Into<String>,
                object_api_name: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::application_object_record::CREATE);
                let op = op
                    .path_param("namespace", namespace.into())
                    .path_param("object_api_name", object_api_name.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                namespace: impl Into<String>,
                object_api_name: impl Into<String>,
                id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::application_object_record::DELETE);
                let op = op
                    .path_param("namespace", namespace.into())
                    .path_param("object_api_name", object_api_name.into())
                    .path_param("id", id.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                namespace: impl Into<String>,
                object_api_name: impl Into<String>,
                id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::application_object_record::PATCH);
                let op = op
                    .path_param("namespace", namespace.into())
                    .path_param("object_api_name", object_api_name.into())
                    .path_param("id", id.into());
                op
            }

            pub fn query<'a>(
                client: &'a Client,
                namespace: impl Into<String>,
                object_api_name: impl Into<String>,
                id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::application_object_record::QUERY);
                let op = op
                    .path_param("namespace", namespace.into())
                    .path_param("object_api_name", object_api_name.into())
                    .path_param("id", id.into());
                op
            }
        }

        pub mod application_record_permission_member {
            use super::*;
            pub fn batch_create_authorization<'a>(
                client: &'a Client,
                namespace: impl Into<String>,
                record_permission_api_name: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::application_record_permission_member::BATCH_CREATE_AUTHORIZATION);
                let op = op.path_param("namespace", namespace.into()).path_param(
                    "record_permission_api_name",
                    record_permission_api_name.into(),
                );
                op
            }

            pub fn batch_remove_authorization<'a>(
                client: &'a Client,
                namespace: impl Into<String>,
                record_permission_api_name: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::application_record_permission_member::BATCH_REMOVE_AUTHORIZATION);
                let op = op.path_param("namespace", namespace.into()).path_param(
                    "record_permission_api_name",
                    record_permission_api_name.into(),
                );
                op
            }
        }

        pub mod application_role_member {
            use super::*;
            pub fn batch_create_authorization<'a>(
                client: &'a Client,
                namespace: impl Into<String>,
                role_api_name: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client
                    .operation(ops::apaas::v1::application_role_member::BATCH_CREATE_AUTHORIZATION);
                let op = op
                    .path_param("namespace", namespace.into())
                    .path_param("role_api_name", role_api_name.into());
                op
            }

            pub fn batch_remove_authorization<'a>(
                client: &'a Client,
                namespace: impl Into<String>,
                role_api_name: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client
                    .operation(ops::apaas::v1::application_role_member::BATCH_REMOVE_AUTHORIZATION);
                let op = op
                    .path_param("namespace", namespace.into())
                    .path_param("role_api_name", role_api_name.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                namespace: impl Into<String>,
                role_api_name: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::application_role_member::GET);
                let op = op
                    .path_param("namespace", namespace.into())
                    .path_param("role_api_name", role_api_name.into());
                op
            }
        }

        pub mod approval_instance {
            use super::*;
            pub fn cancel<'a>(
                client: &'a Client,
                approval_instance_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::approval_instance::CANCEL);
                let op = op.path_param("approval_instance_id", approval_instance_id.into());
                op
            }
        }

        pub mod approval_task {
            use super::*;
            pub fn add_assignee<'a>(
                client: &'a Client,
                approval_task_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::approval_task::ADD_ASSIGNEE);
                let op = op.path_param("approval_task_id", approval_task_id.into());
                op
            }

            pub fn agree<'a>(
                client: &'a Client,
                approval_task_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::approval_task::AGREE);
                let op = op.path_param("approval_task_id", approval_task_id.into());
                op
            }

            pub fn reject<'a>(
                client: &'a Client,
                approval_task_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::approval_task::REJECT);
                let op = op.path_param("approval_task_id", approval_task_id.into());
                op
            }

            pub fn transfer<'a>(
                client: &'a Client,
                approval_task_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::approval_task::TRANSFER);
                let op = op.path_param("approval_task_id", approval_task_id.into());
                op
            }
        }

        pub mod seat_activity {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::seat_activity::LIST);
                op
            }
        }

        pub mod seat_assignment {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::seat_assignment::LIST);
                op
            }
        }

        pub mod user_task {
            use super::*;
            pub fn cc<'a>(client: &'a Client, task_id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::user_task::CC);
                let op = op.path_param("task_id", task_id.into());
                op
            }

            pub fn chat_group<'a>(
                client: &'a Client,
                task_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::user_task::CHAT_GROUP);
                let op = op.path_param("task_id", task_id.into());
                op
            }

            pub fn expediting<'a>(
                client: &'a Client,
                task_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::user_task::EXPEDITING);
                let op = op.path_param("task_id", task_id.into());
                op
            }

            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::user_task::QUERY);
                op
            }

            pub fn rollback<'a>(
                client: &'a Client,
                task_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::user_task::ROLLBACK);
                let op = op.path_param("task_id", task_id.into());
                op
            }

            pub fn rollback_points<'a>(
                client: &'a Client,
                task_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::user_task::ROLLBACK_POINTS);
                let op = op.path_param("task_id", task_id.into());
                op
            }
        }

        pub mod workspace {
            use super::*;
            pub fn sql_commands<'a>(
                client: &'a Client,
                workspace_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::workspace::SQL_COMMANDS);
                let op = op.path_param("workspace_id", workspace_id.into());
                op
            }
        }

        pub mod workspace_enum {
            use super::*;
            pub fn enum_get<'a>(
                client: &'a Client,
                workspace_id: impl Into<String>,
                enum_name: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::workspace_enum::ENUM_GET);
                let op = op
                    .path_param("workspace_id", workspace_id.into())
                    .path_param("enum_name", enum_name.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                workspace_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::workspace_enum::LIST);
                let op = op.path_param("workspace_id", workspace_id.into());
                op
            }
        }

        pub mod workspace_table {
            use super::*;
            pub fn list<'a>(
                client: &'a Client,
                workspace_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::workspace_table::LIST);
                let op = op.path_param("workspace_id", workspace_id.into());
                op
            }

            pub fn records_batch_update<'a>(
                client: &'a Client,
                workspace_id: impl Into<String>,
                table_name: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::workspace_table::RECORDS_BATCH_UPDATE);
                let op = op
                    .path_param("workspace_id", workspace_id.into())
                    .path_param("table_name", table_name.into());
                op
            }

            pub fn records_delete<'a>(
                client: &'a Client,
                workspace_id: impl Into<String>,
                table_name: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::workspace_table::RECORDS_DELETE);
                let op = op
                    .path_param("workspace_id", workspace_id.into())
                    .path_param("table_name", table_name.into());
                op
            }

            pub fn records_get<'a>(
                client: &'a Client,
                workspace_id: impl Into<String>,
                table_name: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::workspace_table::RECORDS_GET);
                let op = op
                    .path_param("workspace_id", workspace_id.into())
                    .path_param("table_name", table_name.into());
                op
            }

            pub fn records_patch<'a>(
                client: &'a Client,
                workspace_id: impl Into<String>,
                table_name: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::workspace_table::RECORDS_PATCH);
                let op = op
                    .path_param("workspace_id", workspace_id.into())
                    .path_param("table_name", table_name.into());
                op
            }

            pub fn records_post<'a>(
                client: &'a Client,
                workspace_id: impl Into<String>,
                table_name: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::workspace_table::RECORDS_POST);
                let op = op
                    .path_param("workspace_id", workspace_id.into())
                    .path_param("table_name", table_name.into());
                op
            }

            pub fn table_get<'a>(
                client: &'a Client,
                workspace_id: impl Into<String>,
                table_name: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::workspace_table::TABLE_GET);
                let op = op
                    .path_param("workspace_id", workspace_id.into())
                    .path_param("table_name", table_name.into());
                op
            }
        }

        pub mod workspace_view {
            use super::*;
            pub fn views_get<'a>(
                client: &'a Client,
                workspace_id: impl Into<String>,
                view_name: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::apaas::v1::workspace_view::VIEWS_GET);
                let op = op
                    .path_param("workspace_id", workspace_id.into())
                    .path_param("view_name", view_name.into());
                op
            }
        }
    }
}

pub mod application {
    use super::*;
    pub mod v6 {
        use super::*;
        pub mod app_badge {
            use super::*;
            pub fn set<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::application::v6::app_badge::SET);
                op
            }
        }

        pub mod app_recommend_rule {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::application::v6::app_recommend_rule::LIST);
                op
            }
        }

        pub mod application {
            use super::*;
            pub fn contacts_range_configuration<'a>(
                client: &'a Client,
                app_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client
                    .operation(ops::application::v6::application::CONTACTS_RANGE_CONFIGURATION);
                let op = op.path_param("app_id", app_id.into());
                op
            }

            pub fn get<'a>(client: &'a Client, app_id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::application::v6::application::GET);
                let op = op.path_param("app_id", app_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::application::v6::application::LIST);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                app_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::application::v6::application::PATCH);
                let op = op.path_param("app_id", app_id.into());
                op
            }

            pub fn underauditlist<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::application::v6::application::UNDERAUDITLIST);
                op
            }
        }

        pub mod application_app_usage {
            use super::*;
            pub fn department_overview<'a>(
                client: &'a Client,
                app_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client
                    .operation(ops::application::v6::application_app_usage::DEPARTMENT_OVERVIEW);
                let op = op.path_param("app_id", app_id.into());
                op
            }

            pub fn message_push_overview<'a>(
                client: &'a Client,
                app_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client
                    .operation(ops::application::v6::application_app_usage::MESSAGE_PUSH_OVERVIEW);
                let op = op.path_param("app_id", app_id.into());
                op
            }

            pub fn overview<'a>(
                client: &'a Client,
                app_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::application::v6::application_app_usage::OVERVIEW);
                let op = op.path_param("app_id", app_id.into());
                op
            }
        }

        pub mod application_app_version {
            use super::*;
            pub fn contacts_range_suggest<'a>(
                client: &'a Client,
                app_id: impl Into<String>,
                version_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(
                    ops::application::v6::application_app_version::CONTACTS_RANGE_SUGGEST,
                );
                let op = op
                    .path_param("app_id", app_id.into())
                    .path_param("version_id", version_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                app_id: impl Into<String>,
                version_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::application::v6::application_app_version::GET);
                let op = op
                    .path_param("app_id", app_id.into())
                    .path_param("version_id", version_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client, app_id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::application::v6::application_app_version::LIST);
                let op = op.path_param("app_id", app_id.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                app_id: impl Into<String>,
                version_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::application::v6::application_app_version::PATCH);
                let op = op
                    .path_param("app_id", app_id.into())
                    .path_param("version_id", version_id.into());
                op
            }
        }

        pub mod application_collaborators {
            use super::*;
            pub fn get<'a>(client: &'a Client, app_id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::application::v6::application_collaborators::GET);
                let op = op.path_param("app_id", app_id.into());
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                app_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::application::v6::application_collaborators::UPDATE);
                let op = op.path_param("app_id", app_id.into());
                op
            }
        }

        pub mod application_contacts_range {
            use super::*;
            pub fn patch<'a>(
                client: &'a Client,
                app_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::application::v6::application_contacts_range::PATCH);
                let op = op.path_param("app_id", app_id.into());
                op
            }
        }

        pub mod application_feedback {
            use super::*;
            pub fn list<'a>(client: &'a Client, app_id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::application::v6::application_feedback::LIST);
                let op = op.path_param("app_id", app_id.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                app_id: impl Into<String>,
                feedback_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::application::v6::application_feedback::PATCH);
                let op = op
                    .path_param("app_id", app_id.into())
                    .path_param("feedback_id", feedback_id.into());
                op
            }
        }

        pub mod application_management {
            use super::*;
            pub fn update<'a>(
                client: &'a Client,
                app_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::application::v6::application_management::UPDATE);
                let op = op.path_param("app_id", app_id.into());
                op
            }
        }

        pub mod application_owner {
            use super::*;
            pub fn update<'a>(
                client: &'a Client,
                app_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::application::v6::application_owner::UPDATE);
                let op = op.path_param("app_id", app_id.into());
                op
            }
        }

        pub mod application_visibility {
            use super::*;
            pub fn check_white_black_list<'a>(
                client: &'a Client,
                app_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(
                    ops::application::v6::application_visibility::CHECK_WHITE_BLACK_LIST,
                );
                let op = op.path_param("app_id", app_id.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                app_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::application::v6::application_visibility::PATCH);
                let op = op.path_param("app_id", app_id.into());
                op
            }
        }

        pub mod scope {
            use super::*;
            pub fn apply<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::application::v6::scope::APPLY);
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::application::v6::scope::LIST);
                op
            }
        }
    }
}

pub mod approval {
    use super::*;
    pub mod v4 {
        use super::*;
        pub mod approval {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::approval::v4::approval::CREATE);
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                approval_code: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::approval::v4::approval::GET);
                let op = op.path_param("approval_code", approval_code.into());
                op
            }

            pub fn subscribe<'a>(
                client: &'a Client,
                approval_code: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::approval::v4::approval::SUBSCRIBE);
                let op = op.path_param("approval_code", approval_code.into());
                op
            }

            pub fn unsubscribe<'a>(
                client: &'a Client,
                approval_code: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::approval::v4::approval::UNSUBSCRIBE);
                let op = op.path_param("approval_code", approval_code.into());
                op
            }
        }

        pub mod external_approval {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::approval::v4::external_approval::CREATE);
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                approval_code: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::approval::v4::external_approval::GET);
                let op = op.path_param("approval_code", approval_code.into());
                op
            }
        }

        pub mod external_instance {
            use super::*;
            pub fn check<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::approval::v4::external_instance::CHECK);
                op
            }

            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::approval::v4::external_instance::CREATE);
                op
            }
        }

        pub mod external_task {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::approval::v4::external_task::LIST);
                op
            }
        }

        pub mod instance {
            use super::*;
            pub fn add_sign<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::approval::v4::instance::ADD_SIGN);
                op
            }

            pub fn cancel<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::approval::v4::instance::CANCEL);
                op
            }

            pub fn cc<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::approval::v4::instance::CC);
                op
            }

            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::approval::v4::instance::CREATE);
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                instance_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::approval::v4::instance::GET);
                let op = op.path_param("instance_id", instance_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::approval::v4::instance::LIST);
                op
            }

            pub fn preview<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::approval::v4::instance::PREVIEW);
                op
            }

            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::approval::v4::instance::QUERY);
                op
            }

            pub fn search_cc<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::approval::v4::instance::SEARCH_CC);
                op
            }

            pub fn specified_rollback<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::approval::v4::instance::SPECIFIED_ROLLBACK);
                op
            }
        }

        pub mod instance_comment {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                instance_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::approval::v4::instance_comment::CREATE);
                let op = op.path_param("instance_id", instance_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                instance_id: impl Into<String>,
                comment_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::approval::v4::instance_comment::DELETE);
                let op = op
                    .path_param("instance_id", instance_id.into())
                    .path_param("comment_id", comment_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                instance_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::approval::v4::instance_comment::LIST);
                let op = op.path_param("instance_id", instance_id.into());
                op
            }

            pub fn remove<'a>(
                client: &'a Client,
                instance_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::approval::v4::instance_comment::REMOVE);
                let op = op.path_param("instance_id", instance_id.into());
                op
            }
        }

        pub mod task {
            use super::*;
            pub fn approve<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::approval::v4::task::APPROVE);
                op
            }

            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::approval::v4::task::QUERY);
                op
            }

            pub fn reject<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::approval::v4::task::REJECT);
                op
            }

            pub fn resubmit<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::approval::v4::task::RESUBMIT);
                op
            }

            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::approval::v4::task::SEARCH);
                op
            }

            pub fn transfer<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::approval::v4::task::TRANSFER);
                op
            }
        }
    }
}

pub mod attendance {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod approval_info {
            use super::*;
            pub fn process<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::approval_info::PROCESS);
                op
            }
        }

        pub mod archive_rule {
            use super::*;
            pub fn del_report<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::archive_rule::DEL_REPORT);
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::archive_rule::LIST);
                op
            }

            pub fn upload_report<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::archive_rule::UPLOAD_REPORT);
                op
            }

            pub fn user_stats_fields_query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op =
                    client.operation(ops::attendance::v1::archive_rule::USER_STATS_FIELDS_QUERY);
                op
            }
        }

        pub mod file {
            use super::*;
            pub fn download<'a>(
                client: &'a Client,
                file_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::file::DOWNLOAD);
                let op = op.path_param("file_id", file_id.into());
                op
            }

            pub fn upload<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::file::UPLOAD);
                op
            }
        }

        pub mod group {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::group::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                group_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::group::DELETE);
                let op = op.path_param("group_id", group_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                group_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::group::GET);
                let op = op.path_param("group_id", group_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::group::LIST);
                op
            }

            pub fn list_user<'a>(
                client: &'a Client,
                group_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::group::LIST_USER);
                let op = op.path_param("group_id", group_id.into());
                op
            }

            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::group::SEARCH);
                op
            }
        }

        pub mod leave_accrual_record {
            use super::*;
            pub fn patch<'a>(
                client: &'a Client,
                leave_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::leave_accrual_record::PATCH);
                let op = op.path_param("leave_id", leave_id.into());
                op
            }
        }

        pub mod leave_employ_expire_record {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                leave_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::leave_employ_expire_record::GET);
                let op = op.path_param("leave_id", leave_id.into());
                op
            }
        }

        pub mod shift {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::shift::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                shift_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::shift::DELETE);
                let op = op.path_param("shift_id", shift_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                shift_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::shift::GET);
                let op = op.path_param("shift_id", shift_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::shift::LIST);
                op
            }

            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::shift::QUERY);
                op
            }
        }

        pub mod user_approval {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::user_approval::CREATE);
                op
            }

            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::user_approval::QUERY);
                op
            }
        }

        pub mod user_daily_shift {
            use super::*;
            pub fn batch_create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::user_daily_shift::BATCH_CREATE);
                op
            }

            pub fn batch_create_temp<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::user_daily_shift::BATCH_CREATE_TEMP);
                op
            }

            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::user_daily_shift::QUERY);
                op
            }
        }

        pub mod user_flow {
            use super::*;
            pub fn batch_create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::user_flow::BATCH_CREATE);
                op
            }

            pub fn batch_del<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::user_flow::BATCH_DEL);
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                user_flow_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::user_flow::GET);
                let op = op.path_param("user_flow_id", user_flow_id.into());
                op
            }

            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::user_flow::QUERY);
                op
            }
        }

        pub mod user_setting {
            use super::*;
            pub fn modify<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::user_setting::MODIFY);
                op
            }

            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::user_setting::QUERY);
                op
            }
        }

        pub mod user_stats_data {
            use super::*;
            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::user_stats_data::QUERY);
                op
            }
        }

        pub mod user_stats_field {
            use super::*;
            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::user_stats_field::QUERY);
                op
            }
        }

        pub mod user_stats_view {
            use super::*;
            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::user_stats_view::QUERY);
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                user_stats_view_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::user_stats_view::UPDATE);
                let op = op.path_param("user_stats_view_id", user_stats_view_id.into());
                op
            }
        }

        pub mod user_task {
            use super::*;
            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::user_task::QUERY);
                op
            }
        }

        pub mod user_task_remedy {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::user_task_remedy::CREATE);
                op
            }

            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::attendance::v1::user_task_remedy::QUERY);
                op
            }

            pub fn query_user_allowed_remedys<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client
                    .operation(ops::attendance::v1::user_task_remedy::QUERY_USER_ALLOWED_REMEDYS);
                op
            }
        }
    }
}

pub mod auth {
    use super::*;
    pub mod v3 {
        use super::*;
        pub mod app_access_token {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::auth::v3::app_access_token::CREATE);
                op
            }

            pub fn internal<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::auth::v3::app_access_token::INTERNAL);
                op
            }
        }

        pub mod app_ticket {
            use super::*;
            pub fn resend<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::auth::v3::app_ticket::RESEND);
                op
            }
        }

        pub mod tenant_access_token {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::auth::v3::tenant_access_token::CREATE);
                op
            }

            pub fn internal<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::auth::v3::tenant_access_token::INTERNAL);
                op
            }
        }
    }
}

pub mod authen {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod access_token {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::authen::v1::access_token::CREATE);
                op
            }
        }

        pub mod oidc_access_token {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::authen::v1::oidc_access_token::CREATE);
                op
            }
        }

        pub mod oidc_refresh_access_token {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::authen::v1::oidc_refresh_access_token::CREATE);
                op
            }
        }

        pub mod refresh_access_token {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::authen::v1::refresh_access_token::CREATE);
                op
            }
        }

        pub mod user_info {
            use super::*;
            pub fn get<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::authen::v1::user_info::GET);
                op
            }
        }
    }
}

pub mod baike {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod classification {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::baike::v1::classification::LIST);
                op
            }
        }

        pub mod draft {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::baike::v1::draft::CREATE);
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                draft_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::baike::v1::draft::UPDATE);
                let op = op.path_param("draft_id", draft_id.into());
                op
            }
        }

        pub mod entity {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::baike::v1::entity::CREATE);
                op
            }

            pub fn extract<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::baike::v1::entity::EXTRACT);
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                entity_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::baike::v1::entity::GET);
                let op = op.path_param("entity_id", entity_id.into());
                op
            }

            pub fn highlight<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::baike::v1::entity::HIGHLIGHT);
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::baike::v1::entity::LIST);
                op
            }

            pub fn match_<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::baike::v1::entity::MATCH);
                op
            }

            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::baike::v1::entity::SEARCH);
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                entity_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::baike::v1::entity::UPDATE);
                let op = op.path_param("entity_id", entity_id.into());
                op
            }
        }

        pub mod file {
            use super::*;
            pub fn download<'a>(
                client: &'a Client,
                file_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::baike::v1::file::DOWNLOAD);
                let op = op.path_param("file_token", file_token.into());
                op
            }

            pub fn upload<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::baike::v1::file::UPLOAD);
                op
            }
        }
    }
}

pub mod base {
    use super::*;
    pub mod v2 {
        use super::*;
        pub mod app_role {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::base::v2::app_role::CREATE);
                let op = op.path_param("app_token", app_token.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::base::v2::app_role::LIST);
                let op = op.path_param("app_token", app_token.into());
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                role_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::base::v2::app_role::UPDATE);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("role_id", role_id.into());
                op
            }
        }
    }
}

pub mod bitable {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod app {
            use super::*;
            pub fn copy<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app::COPY);
                let op = op.path_param("app_token", app_token.into());
                op
            }

            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app::CREATE);
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app::GET);
                let op = op.path_param("app_token", app_token.into());
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app::UPDATE);
                let op = op.path_param("app_token", app_token.into());
                op
            }
        }

        pub mod app_dashboard {
            use super::*;
            pub fn copy<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                block_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_dashboard::COPY);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("block_id", block_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_dashboard::LIST);
                let op = op.path_param("app_token", app_token.into());
                op
            }
        }

        pub mod app_role {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_role::CREATE);
                let op = op.path_param("app_token", app_token.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                role_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_role::DELETE);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("role_id", role_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_role::LIST);
                let op = op.path_param("app_token", app_token.into());
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                role_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_role::UPDATE);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("role_id", role_id.into());
                op
            }
        }

        pub mod app_role_member {
            use super::*;
            pub fn batch_create<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                role_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_role_member::BATCH_CREATE);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("role_id", role_id.into());
                op
            }

            pub fn batch_delete<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                role_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_role_member::BATCH_DELETE);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("role_id", role_id.into());
                op
            }

            pub fn create<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                role_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_role_member::CREATE);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("role_id", role_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                role_id: impl Into<String>,
                member_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_role_member::DELETE);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("role_id", role_id.into())
                    .path_param("member_id", member_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                role_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_role_member::LIST);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("role_id", role_id.into());
                op
            }
        }

        pub mod app_table {
            use super::*;
            pub fn batch_create<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_table::BATCH_CREATE);
                let op = op.path_param("app_token", app_token.into());
                op
            }

            pub fn batch_delete<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_table::BATCH_DELETE);
                let op = op.path_param("app_token", app_token.into());
                op
            }

            pub fn create<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_table::CREATE);
                let op = op.path_param("app_token", app_token.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                table_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_table::DELETE);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("table_id", table_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_table::LIST);
                let op = op.path_param("app_token", app_token.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                table_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_table::PATCH);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("table_id", table_id.into());
                op
            }
        }

        pub mod app_table_field {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                table_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_table_field::CREATE);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("table_id", table_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                table_id: impl Into<String>,
                field_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_table_field::DELETE);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("table_id", table_id.into())
                    .path_param("field_id", field_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                table_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_table_field::LIST);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("table_id", table_id.into());
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                table_id: impl Into<String>,
                field_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_table_field::UPDATE);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("table_id", table_id.into())
                    .path_param("field_id", field_id.into());
                op
            }
        }

        pub mod app_table_form {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                table_id: impl Into<String>,
                form_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_table_form::GET);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("table_id", table_id.into())
                    .path_param("form_id", form_id.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                table_id: impl Into<String>,
                form_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_table_form::PATCH);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("table_id", table_id.into())
                    .path_param("form_id", form_id.into());
                op
            }
        }

        pub mod app_table_form_field {
            use super::*;
            pub fn list<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                table_id: impl Into<String>,
                form_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_table_form_field::LIST);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("table_id", table_id.into())
                    .path_param("form_id", form_id.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                table_id: impl Into<String>,
                form_id: impl Into<String>,
                field_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_table_form_field::PATCH);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("table_id", table_id.into())
                    .path_param("form_id", form_id.into())
                    .path_param("field_id", field_id.into());
                op
            }
        }

        pub mod app_table_record {
            use super::*;
            pub fn batch_create<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                table_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_table_record::BATCH_CREATE);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("table_id", table_id.into());
                op
            }

            pub fn batch_delete<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                table_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_table_record::BATCH_DELETE);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("table_id", table_id.into());
                op
            }

            pub fn batch_get<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                table_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_table_record::BATCH_GET);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("table_id", table_id.into());
                op
            }

            pub fn batch_update<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                table_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_table_record::BATCH_UPDATE);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("table_id", table_id.into());
                op
            }

            pub fn create<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                table_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_table_record::CREATE);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("table_id", table_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                table_id: impl Into<String>,
                record_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_table_record::DELETE);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("table_id", table_id.into())
                    .path_param("record_id", record_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                table_id: impl Into<String>,
                record_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_table_record::GET);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("table_id", table_id.into())
                    .path_param("record_id", record_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                table_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_table_record::LIST);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("table_id", table_id.into());
                op
            }

            pub fn search<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                table_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_table_record::SEARCH);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("table_id", table_id.into());
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                table_id: impl Into<String>,
                record_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_table_record::UPDATE);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("table_id", table_id.into())
                    .path_param("record_id", record_id.into());
                op
            }
        }

        pub mod app_table_view {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                table_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_table_view::CREATE);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("table_id", table_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                table_id: impl Into<String>,
                view_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_table_view::DELETE);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("table_id", table_id.into())
                    .path_param("view_id", view_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                table_id: impl Into<String>,
                view_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_table_view::GET);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("table_id", table_id.into())
                    .path_param("view_id", view_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                table_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_table_view::LIST);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("table_id", table_id.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                table_id: impl Into<String>,
                view_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_table_view::PATCH);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("table_id", table_id.into())
                    .path_param("view_id", view_id.into());
                op
            }
        }

        pub mod app_workflow {
            use super::*;
            pub fn list<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_workflow::LIST);
                let op = op.path_param("app_token", app_token.into());
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                app_token: impl Into<String>,
                workflow_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::bitable::v1::app_workflow::UPDATE);
                let op = op
                    .path_param("app_token", app_token.into())
                    .path_param("workflow_id", workflow_id.into());
                op
            }
        }
    }
}

pub mod block {
    use super::*;
    pub mod v2 {
        use super::*;
        pub mod entity {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::block::v2::entity::CREATE);
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                block_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::block::v2::entity::UPDATE);
                let op = op.path_param("block_id", block_id.into());
                op
            }
        }

        pub mod message {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::block::v2::message::CREATE);
                op
            }
        }
    }
}

pub mod board {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod whiteboard {
            use super::*;
            pub fn download_as_image<'a>(
                client: &'a Client,
                whiteboard_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::board::v1::whiteboard::DOWNLOAD_AS_IMAGE);
                let op = op.path_param("whiteboard_id", whiteboard_id.into());
                op
            }

            pub fn theme<'a>(
                client: &'a Client,
                whiteboard_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::board::v1::whiteboard::THEME);
                let op = op.path_param("whiteboard_id", whiteboard_id.into());
                op
            }

            pub fn update_theme<'a>(
                client: &'a Client,
                whiteboard_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::board::v1::whiteboard::UPDATE_THEME);
                let op = op.path_param("whiteboard_id", whiteboard_id.into());
                op
            }
        }

        pub mod whiteboard_node {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                whiteboard_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::board::v1::whiteboard_node::CREATE);
                let op = op.path_param("whiteboard_id", whiteboard_id.into());
                op
            }

            pub fn create_plantuml<'a>(
                client: &'a Client,
                whiteboard_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::board::v1::whiteboard_node::CREATE_PLANTUML);
                let op = op.path_param("whiteboard_id", whiteboard_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                whiteboard_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::board::v1::whiteboard_node::LIST);
                let op = op.path_param("whiteboard_id", whiteboard_id.into());
                op
            }
        }
    }
}

pub mod calendar {
    use super::*;
    pub mod v4 {
        use super::*;
        pub mod calendar {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                calendar_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar::DELETE);
                let op = op.path_param("calendar_id", calendar_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                calendar_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar::GET);
                let op = op.path_param("calendar_id", calendar_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar::LIST);
                op
            }

            pub fn mget<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar::MGET);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                calendar_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar::PATCH);
                let op = op.path_param("calendar_id", calendar_id.into());
                op
            }

            pub fn primary<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar::PRIMARY);
                op
            }

            pub fn primarys<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar::PRIMARYS);
                op
            }

            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar::SEARCH);
                op
            }

            pub fn subscribe<'a>(
                client: &'a Client,
                calendar_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar::SUBSCRIBE);
                let op = op.path_param("calendar_id", calendar_id.into());
                op
            }

            pub fn subscription<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar::SUBSCRIPTION);
                op
            }

            pub fn unsubscribe<'a>(
                client: &'a Client,
                calendar_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar::UNSUBSCRIBE);
                let op = op.path_param("calendar_id", calendar_id.into());
                op
            }

            pub fn unsubscription<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar::UNSUBSCRIPTION);
                op
            }
        }

        pub mod calendar_acl {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                calendar_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar_acl::CREATE);
                let op = op.path_param("calendar_id", calendar_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                calendar_id: impl Into<String>,
                acl_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar_acl::DELETE);
                let op = op
                    .path_param("calendar_id", calendar_id.into())
                    .path_param("acl_id", acl_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                calendar_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar_acl::LIST);
                let op = op.path_param("calendar_id", calendar_id.into());
                op
            }

            pub fn subscription<'a>(
                client: &'a Client,
                calendar_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar_acl::SUBSCRIPTION);
                let op = op.path_param("calendar_id", calendar_id.into());
                op
            }

            pub fn unsubscription<'a>(
                client: &'a Client,
                calendar_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar_acl::UNSUBSCRIPTION);
                let op = op.path_param("calendar_id", calendar_id.into());
                op
            }
        }

        pub mod calendar_event {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                calendar_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar_event::CREATE);
                let op = op.path_param("calendar_id", calendar_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                calendar_id: impl Into<String>,
                event_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar_event::DELETE);
                let op = op
                    .path_param("calendar_id", calendar_id.into())
                    .path_param("event_id", event_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                calendar_id: impl Into<String>,
                event_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar_event::GET);
                let op = op
                    .path_param("calendar_id", calendar_id.into())
                    .path_param("event_id", event_id.into());
                op
            }

            pub fn instance_view<'a>(
                client: &'a Client,
                calendar_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar_event::INSTANCE_VIEW);
                let op = op.path_param("calendar_id", calendar_id.into());
                op
            }

            pub fn instances<'a>(
                client: &'a Client,
                calendar_id: impl Into<String>,
                event_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar_event::INSTANCES);
                let op = op
                    .path_param("calendar_id", calendar_id.into())
                    .path_param("event_id", event_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                calendar_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar_event::LIST);
                let op = op.path_param("calendar_id", calendar_id.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                calendar_id: impl Into<String>,
                event_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar_event::PATCH);
                let op = op
                    .path_param("calendar_id", calendar_id.into())
                    .path_param("event_id", event_id.into());
                op
            }

            pub fn reply<'a>(
                client: &'a Client,
                calendar_id: impl Into<String>,
                event_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar_event::REPLY);
                let op = op
                    .path_param("calendar_id", calendar_id.into())
                    .path_param("event_id", event_id.into());
                op
            }

            pub fn search<'a>(
                client: &'a Client,
                calendar_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar_event::SEARCH);
                let op = op.path_param("calendar_id", calendar_id.into());
                op
            }

            pub fn subscription<'a>(
                client: &'a Client,
                calendar_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar_event::SUBSCRIPTION);
                let op = op.path_param("calendar_id", calendar_id.into());
                op
            }

            pub fn unsubscription<'a>(
                client: &'a Client,
                calendar_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar_event::UNSUBSCRIPTION);
                let op = op.path_param("calendar_id", calendar_id.into());
                op
            }
        }

        pub mod calendar_event_attendee {
            use super::*;
            pub fn batch_delete<'a>(
                client: &'a Client,
                calendar_id: impl Into<String>,
                event_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar_event_attendee::BATCH_DELETE);
                let op = op
                    .path_param("calendar_id", calendar_id.into())
                    .path_param("event_id", event_id.into());
                op
            }

            pub fn create<'a>(
                client: &'a Client,
                calendar_id: impl Into<String>,
                event_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar_event_attendee::CREATE);
                let op = op
                    .path_param("calendar_id", calendar_id.into())
                    .path_param("event_id", event_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                calendar_id: impl Into<String>,
                event_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar_event_attendee::LIST);
                let op = op
                    .path_param("calendar_id", calendar_id.into())
                    .path_param("event_id", event_id.into());
                op
            }
        }

        pub mod calendar_event_attendee_chat_member {
            use super::*;
            pub fn list<'a>(
                client: &'a Client,
                calendar_id: impl Into<String>,
                event_id: impl Into<String>,
                attendee_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op =
                    client.operation(ops::calendar::v4::calendar_event_attendee_chat_member::LIST);
                let op = op
                    .path_param("calendar_id", calendar_id.into())
                    .path_param("event_id", event_id.into())
                    .path_param("attendee_id", attendee_id.into());
                op
            }
        }

        pub mod calendar_event_meeting_chat {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                calendar_id: impl Into<String>,
                event_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar_event_meeting_chat::CREATE);
                let op = op
                    .path_param("calendar_id", calendar_id.into())
                    .path_param("event_id", event_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                calendar_id: impl Into<String>,
                event_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar_event_meeting_chat::DELETE);
                let op = op
                    .path_param("calendar_id", calendar_id.into())
                    .path_param("event_id", event_id.into());
                op
            }
        }

        pub mod calendar_event_meeting_minute {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                calendar_id: impl Into<String>,
                event_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::calendar_event_meeting_minute::CREATE);
                let op = op
                    .path_param("calendar_id", calendar_id.into())
                    .path_param("event_id", event_id.into());
                op
            }
        }

        pub mod exchange_binding {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::exchange_binding::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                exchange_binding_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::exchange_binding::DELETE);
                let op = op.path_param("exchange_binding_id", exchange_binding_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                exchange_binding_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::exchange_binding::GET);
                let op = op.path_param("exchange_binding_id", exchange_binding_id.into());
                op
            }
        }

        pub mod freebusy {
            use super::*;
            pub fn batch<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::freebusy::BATCH);
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::freebusy::LIST);
                op
            }
        }

        pub mod setting {
            use super::*;
            pub fn generate_caldav_conf<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::setting::GENERATE_CALDAV_CONF);
                op
            }
        }

        pub mod timeoff_event {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::timeoff_event::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                timeoff_event_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::calendar::v4::timeoff_event::DELETE);
                let op = op.path_param("timeoff_event_id", timeoff_event_id.into());
                op
            }
        }
    }
}

pub mod cardkit {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod card {
            use super::*;
            pub fn batch_update<'a>(
                client: &'a Client,
                card_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::cardkit::v1::card::BATCH_UPDATE);
                let op = op.path_param("card_id", card_id.into());
                op
            }

            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::cardkit::v1::card::CREATE);
                op
            }

            pub fn id_convert<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::cardkit::v1::card::ID_CONVERT);
                op
            }

            pub fn settings<'a>(
                client: &'a Client,
                card_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::cardkit::v1::card::SETTINGS);
                let op = op.path_param("card_id", card_id.into());
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                card_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::cardkit::v1::card::UPDATE);
                let op = op.path_param("card_id", card_id.into());
                op
            }
        }

        pub mod card_element {
            use super::*;
            pub fn content<'a>(
                client: &'a Client,
                card_id: impl Into<String>,
                element_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::cardkit::v1::card_element::CONTENT);
                let op = op
                    .path_param("card_id", card_id.into())
                    .path_param("element_id", element_id.into());
                op
            }

            pub fn create<'a>(
                client: &'a Client,
                card_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::cardkit::v1::card_element::CREATE);
                let op = op.path_param("card_id", card_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                card_id: impl Into<String>,
                element_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::cardkit::v1::card_element::DELETE);
                let op = op
                    .path_param("card_id", card_id.into())
                    .path_param("element_id", element_id.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                card_id: impl Into<String>,
                element_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::cardkit::v1::card_element::PATCH);
                let op = op
                    .path_param("card_id", card_id.into())
                    .path_param("element_id", element_id.into());
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                card_id: impl Into<String>,
                element_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::cardkit::v1::card_element::UPDATE);
                let op = op
                    .path_param("card_id", card_id.into())
                    .path_param("element_id", element_id.into());
                op
            }
        }
    }
}

pub mod compensation {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod archive {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::compensation::v1::archive::CREATE);
                op
            }

            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::compensation::v1::archive::QUERY);
                op
            }
        }

        pub mod change_reason {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::compensation::v1::change_reason::LIST);
                op
            }
        }

        pub mod indicator {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::compensation::v1::indicator::LIST);
                op
            }
        }

        pub mod item {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::compensation::v1::item::LIST);
                op
            }
        }

        pub mod item_category {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::compensation::v1::item_category::LIST);
                op
            }
        }

        pub mod lump_sum_payment {
            use super::*;
            pub fn batch_create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::compensation::v1::lump_sum_payment::BATCH_CREATE);
                op
            }

            pub fn batch_remove<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::compensation::v1::lump_sum_payment::BATCH_REMOVE);
                op
            }

            pub fn batch_update<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::compensation::v1::lump_sum_payment::BATCH_UPDATE);
                op
            }

            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::compensation::v1::lump_sum_payment::QUERY);
                op
            }

            pub fn query_detail<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::compensation::v1::lump_sum_payment::QUERY_DETAIL);
                op
            }
        }

        pub mod plan {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::compensation::v1::plan::LIST);
                op
            }
        }

        pub mod recurring_payment {
            use super::*;
            pub fn batch_create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::compensation::v1::recurring_payment::BATCH_CREATE);
                op
            }

            pub fn batch_remove<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::compensation::v1::recurring_payment::BATCH_REMOVE);
                op
            }

            pub fn batch_update<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::compensation::v1::recurring_payment::BATCH_UPDATE);
                op
            }

            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::compensation::v1::recurring_payment::QUERY);
                op
            }
        }

        pub mod social_archive {
            use super::*;
            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::compensation::v1::social_archive::QUERY);
                op
            }
        }

        pub mod social_archive_adjust_record {
            use super::*;
            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op =
                    client.operation(ops::compensation::v1::social_archive_adjust_record::QUERY);
                op
            }
        }

        pub mod social_insurance {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::compensation::v1::social_insurance::LIST);
                op
            }
        }

        pub mod social_plan {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::compensation::v1::social_plan::LIST);
                op
            }

            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::compensation::v1::social_plan::QUERY);
                op
            }
        }
    }
}

pub mod contact {
    use super::*;
    pub mod v3 {
        use super::*;
        pub mod custom_attr {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::custom_attr::LIST);
                op
            }
        }

        pub mod department {
            use super::*;
            pub fn batch<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::department::BATCH);
                op
            }

            pub fn children<'a>(
                client: &'a Client,
                department_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::department::CHILDREN);
                let op = op.path_param("department_id", department_id.into());
                op
            }

            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::department::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                department_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::department::DELETE);
                let op = op.path_param("department_id", department_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                department_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::department::GET);
                let op = op.path_param("department_id", department_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::department::LIST);
                op
            }

            pub fn parent<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::department::PARENT);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                department_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::department::PATCH);
                let op = op.path_param("department_id", department_id.into());
                op
            }

            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::department::SEARCH);
                op
            }

            pub fn unbind_department_chat<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::department::UNBIND_DEPARTMENT_CHAT);
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                department_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::department::UPDATE);
                let op = op.path_param("department_id", department_id.into());
                op
            }

            pub fn update_department_id<'a>(
                client: &'a Client,
                department_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::department::UPDATE_DEPARTMENT_ID);
                let op = op.path_param("department_id", department_id.into());
                op
            }
        }

        pub mod employee_type_enum {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::employee_type_enum::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                enum_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::employee_type_enum::DELETE);
                let op = op.path_param("enum_id", enum_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::employee_type_enum::LIST);
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                enum_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::employee_type_enum::UPDATE);
                let op = op.path_param("enum_id", enum_id.into());
                op
            }
        }

        pub mod functional_role {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::functional_role::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                role_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::functional_role::DELETE);
                let op = op.path_param("role_id", role_id.into());
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                role_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::functional_role::UPDATE);
                let op = op.path_param("role_id", role_id.into());
                op
            }
        }

        pub mod functional_role_member {
            use super::*;
            pub fn batch_create<'a>(
                client: &'a Client,
                role_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::functional_role_member::BATCH_CREATE);
                let op = op.path_param("role_id", role_id.into());
                op
            }

            pub fn batch_delete<'a>(
                client: &'a Client,
                role_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::functional_role_member::BATCH_DELETE);
                let op = op.path_param("role_id", role_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                role_id: impl Into<String>,
                member_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::functional_role_member::GET);
                let op = op
                    .path_param("role_id", role_id.into())
                    .path_param("member_id", member_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                role_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::functional_role_member::LIST);
                let op = op.path_param("role_id", role_id.into());
                op
            }

            pub fn scopes<'a>(
                client: &'a Client,
                role_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::functional_role_member::SCOPES);
                let op = op.path_param("role_id", role_id.into());
                op
            }
        }

        pub mod group {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::group::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                group_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::group::DELETE);
                let op = op.path_param("group_id", group_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                group_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::group::GET);
                let op = op.path_param("group_id", group_id.into());
                op
            }

            pub fn member_belong<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::group::MEMBER_BELONG);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                group_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::group::PATCH);
                let op = op.path_param("group_id", group_id.into());
                op
            }

            pub fn simplelist<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::group::SIMPLELIST);
                op
            }
        }

        pub mod group_member {
            use super::*;
            pub fn add<'a>(
                client: &'a Client,
                group_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::group_member::ADD);
                let op = op.path_param("group_id", group_id.into());
                op
            }

            pub fn batch_add<'a>(
                client: &'a Client,
                group_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::group_member::BATCH_ADD);
                let op = op.path_param("group_id", group_id.into());
                op
            }

            pub fn batch_remove<'a>(
                client: &'a Client,
                group_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::group_member::BATCH_REMOVE);
                let op = op.path_param("group_id", group_id.into());
                op
            }

            pub fn remove<'a>(
                client: &'a Client,
                group_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::group_member::REMOVE);
                let op = op.path_param("group_id", group_id.into());
                op
            }

            pub fn simplelist<'a>(
                client: &'a Client,
                group_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::group_member::SIMPLELIST);
                let op = op.path_param("group_id", group_id.into());
                op
            }
        }

        pub mod job_family {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::job_family::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                job_family_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::job_family::DELETE);
                let op = op.path_param("job_family_id", job_family_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                job_family_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::job_family::GET);
                let op = op.path_param("job_family_id", job_family_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::job_family::LIST);
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                job_family_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::job_family::UPDATE);
                let op = op.path_param("job_family_id", job_family_id.into());
                op
            }
        }

        pub mod job_level {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::job_level::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                job_level_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::job_level::DELETE);
                let op = op.path_param("job_level_id", job_level_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                job_level_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::job_level::GET);
                let op = op.path_param("job_level_id", job_level_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::job_level::LIST);
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                job_level_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::job_level::UPDATE);
                let op = op.path_param("job_level_id", job_level_id.into());
                op
            }
        }

        pub mod job_title {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                job_title_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::job_title::GET);
                let op = op.path_param("job_title_id", job_title_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::job_title::LIST);
                op
            }
        }

        pub mod scope {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::scope::LIST);
                op
            }
        }

        pub mod unit {
            use super::*;
            pub fn bind_department<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::unit::BIND_DEPARTMENT);
                op
            }

            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::unit::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                unit_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::unit::DELETE);
                let op = op.path_param("unit_id", unit_id.into());
                op
            }

            pub fn get<'a>(client: &'a Client, unit_id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::unit::GET);
                let op = op.path_param("unit_id", unit_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::unit::LIST);
                op
            }

            pub fn list_department<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::unit::LIST_DEPARTMENT);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                unit_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::unit::PATCH);
                let op = op.path_param("unit_id", unit_id.into());
                op
            }

            pub fn unbind_department<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::unit::UNBIND_DEPARTMENT);
                op
            }
        }

        pub mod user {
            use super::*;
            pub fn batch<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::user::BATCH);
                op
            }

            pub fn batch_get_id<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::user::BATCH_GET_ID);
                op
            }

            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::user::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                user_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::user::DELETE);
                let op = op.path_param("user_id", user_id.into());
                op
            }

            pub fn find_by_department<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::user::FIND_BY_DEPARTMENT);
                op
            }

            pub fn get<'a>(client: &'a Client, user_id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::user::GET);
                let op = op.path_param("user_id", user_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::user::LIST);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                user_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::user::PATCH);
                let op = op.path_param("user_id", user_id.into());
                op
            }

            pub fn resurrect<'a>(
                client: &'a Client,
                user_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::user::RESURRECT);
                let op = op.path_param("user_id", user_id.into());
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                user_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::user::UPDATE);
                let op = op.path_param("user_id", user_id.into());
                op
            }

            pub fn update_user_id<'a>(
                client: &'a Client,
                user_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::user::UPDATE_USER_ID);
                let op = op.path_param("user_id", user_id.into());
                op
            }
        }

        pub mod work_city {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                work_city_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::work_city::GET);
                let op = op.path_param("work_city_id", work_city_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::contact::v3::work_city::LIST);
                op
            }
        }
    }
}

pub mod corehr {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod assigned_user {
            use super::*;
            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::assigned_user::SEARCH);
                op
            }
        }

        pub mod authorization {
            use super::*;
            pub fn add_role_assign<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::authorization::ADD_ROLE_ASSIGN);
                op
            }

            pub fn get_by_param<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::authorization::GET_BY_PARAM);
                op
            }

            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::authorization::QUERY);
                op
            }

            pub fn remove_role_assign<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::authorization::REMOVE_ROLE_ASSIGN);
                op
            }

            pub fn update_role_assign<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::authorization::UPDATE_ROLE_ASSIGN);
                op
            }
        }

        pub mod common_data_id {
            use super::*;
            pub fn convert<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::common_data_id::CONVERT);
                op
            }
        }

        pub mod common_data_meta_data {
            use super::*;
            pub fn add_enum_option<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::common_data_meta_data::ADD_ENUM_OPTION);
                op
            }

            pub fn edit_enum_option<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::common_data_meta_data::EDIT_ENUM_OPTION);
                op
            }
        }

        pub mod company {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::company::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                company_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::company::DELETE);
                let op = op.path_param("company_id", company_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                company_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::company::GET);
                let op = op.path_param("company_id", company_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::company::LIST);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                company_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::company::PATCH);
                let op = op.path_param("company_id", company_id.into());
                op
            }
        }

        pub mod compensation_standard {
            use super::*;
            pub fn match_<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::compensation_standard::MATCH);
                op
            }
        }

        pub mod contract {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::contract::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                contract_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::contract::DELETE);
                let op = op.path_param("contract_id", contract_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                contract_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::contract::GET);
                let op = op.path_param("contract_id", contract_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::contract::LIST);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                contract_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::contract::PATCH);
                let op = op.path_param("contract_id", contract_id.into());
                op
            }
        }

        pub mod country_region {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                country_region_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::country_region::GET);
                let op = op.path_param("country_region_id", country_region_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::country_region::LIST);
                op
            }
        }

        pub mod currency {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                currency_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::currency::GET);
                let op = op.path_param("currency_id", currency_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::currency::LIST);
                op
            }
        }

        pub mod custom_field {
            use super::*;
            pub fn get_by_param<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::custom_field::GET_BY_PARAM);
                op
            }

            pub fn list_object_api_name<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::custom_field::LIST_OBJECT_API_NAME);
                op
            }

            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::custom_field::QUERY);
                op
            }
        }

        pub mod department {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::department::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                department_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::department::DELETE);
                let op = op.path_param("department_id", department_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                department_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::department::GET);
                let op = op.path_param("department_id", department_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::department::LIST);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                department_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::department::PATCH);
                let op = op.path_param("department_id", department_id.into());
                op
            }
        }

        pub mod employee_type {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::employee_type::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                employee_type_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::employee_type::DELETE);
                let op = op.path_param("employee_type_id", employee_type_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                employee_type_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::employee_type::GET);
                let op = op.path_param("employee_type_id", employee_type_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::employee_type::LIST);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                employee_type_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::employee_type::PATCH);
                let op = op.path_param("employee_type_id", employee_type_id.into());
                op
            }
        }

        pub mod employment {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::employment::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                employment_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::employment::DELETE);
                let op = op.path_param("employment_id", employment_id.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                employment_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::employment::PATCH);
                let op = op.path_param("employment_id", employment_id.into());
                op
            }
        }

        pub mod file {
            use super::*;
            pub fn get<'a>(client: &'a Client, id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::file::GET);
                let op = op.path_param("id", id.into());
                op
            }
        }

        pub mod job {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::job::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                job_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::job::DELETE);
                let op = op.path_param("job_id", job_id.into());
                op
            }

            pub fn get<'a>(client: &'a Client, job_id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::job::GET);
                let op = op.path_param("job_id", job_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::job::LIST);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                job_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::job::PATCH);
                let op = op.path_param("job_id", job_id.into());
                op
            }
        }

        pub mod job_change {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::job_change::CREATE);
                op
            }
        }

        pub mod job_data {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::job_data::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                job_data_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::job_data::DELETE);
                let op = op.path_param("job_data_id", job_data_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                job_data_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::job_data::GET);
                let op = op.path_param("job_data_id", job_data_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::job_data::LIST);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                job_data_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::job_data::PATCH);
                let op = op.path_param("job_data_id", job_data_id.into());
                op
            }
        }

        pub mod job_family {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::job_family::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                job_family_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::job_family::DELETE);
                let op = op.path_param("job_family_id", job_family_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                job_family_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::job_family::GET);
                let op = op.path_param("job_family_id", job_family_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::job_family::LIST);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                job_family_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::job_family::PATCH);
                let op = op.path_param("job_family_id", job_family_id.into());
                op
            }
        }

        pub mod job_level {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::job_level::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                job_level_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::job_level::DELETE);
                let op = op.path_param("job_level_id", job_level_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                job_level_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::job_level::GET);
                let op = op.path_param("job_level_id", job_level_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::job_level::LIST);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                job_level_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::job_level::PATCH);
                let op = op.path_param("job_level_id", job_level_id.into());
                op
            }
        }

        pub mod leave {
            use super::*;
            pub fn calendar_by_scope<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::leave::CALENDAR_BY_SCOPE);
                op
            }

            pub fn leave_balances<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::leave::LEAVE_BALANCES);
                op
            }

            pub fn leave_request_history<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::leave::LEAVE_REQUEST_HISTORY);
                op
            }

            pub fn leave_types<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::leave::LEAVE_TYPES);
                op
            }

            pub fn work_calendar<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::leave::WORK_CALENDAR);
                op
            }

            pub fn work_calendar_date<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::leave::WORK_CALENDAR_DATE);
                op
            }
        }

        pub mod leave_granting_record {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::leave_granting_record::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                leave_granting_record_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::leave_granting_record::DELETE);
                let op = op.path_param("leave_granting_record_id", leave_granting_record_id.into());
                op
            }
        }

        pub mod location {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::location::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                location_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::location::DELETE);
                let op = op.path_param("location_id", location_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                location_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::location::GET);
                let op = op.path_param("location_id", location_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::location::LIST);
                op
            }
        }

        pub mod national_id_type {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::national_id_type::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                national_id_type_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::national_id_type::DELETE);
                let op = op.path_param("national_id_type_id", national_id_type_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                national_id_type_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::national_id_type::GET);
                let op = op.path_param("national_id_type_id", national_id_type_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::national_id_type::LIST);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                national_id_type_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::national_id_type::PATCH);
                let op = op.path_param("national_id_type_id", national_id_type_id.into());
                op
            }
        }

        pub mod offboarding {
            use super::*;
            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::offboarding::QUERY);
                op
            }

            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::offboarding::SEARCH);
                op
            }

            pub fn submit<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::offboarding::SUBMIT);
                op
            }
        }

        pub mod person {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::person::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                person_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::person::DELETE);
                let op = op.path_param("person_id", person_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                person_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::person::GET);
                let op = op.path_param("person_id", person_id.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                person_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::person::PATCH);
                let op = op.path_param("person_id", person_id.into());
                op
            }

            pub fn upload<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::person::UPLOAD);
                op
            }
        }

        pub mod pre_hire {
            use super::*;
            pub fn delete<'a>(
                client: &'a Client,
                pre_hire_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::pre_hire::DELETE);
                let op = op.path_param("pre_hire_id", pre_hire_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                pre_hire_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::pre_hire::GET);
                let op = op.path_param("pre_hire_id", pre_hire_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::pre_hire::LIST);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                pre_hire_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::pre_hire::PATCH);
                let op = op.path_param("pre_hire_id", pre_hire_id.into());
                op
            }
        }

        pub mod process_form_variable_data {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                process_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::process_form_variable_data::GET);
                let op = op.path_param("process_id", process_id.into());
                op
            }
        }

        pub mod security_group {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::security_group::LIST);
                op
            }

            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::security_group::QUERY);
                op
            }
        }

        pub mod subdivision {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                subdivision_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::subdivision::GET);
                let op = op.path_param("subdivision_id", subdivision_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::subdivision::LIST);
                op
            }
        }

        pub mod subregion {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                subregion_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::subregion::GET);
                let op = op.path_param("subregion_id", subregion_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::subregion::LIST);
                op
            }
        }

        pub mod transfer_reason {
            use super::*;
            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::transfer_reason::QUERY);
                op
            }
        }

        pub mod transfer_type {
            use super::*;
            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::transfer_type::QUERY);
                op
            }
        }

        pub mod working_hours_type {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::working_hours_type::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                working_hours_type_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::working_hours_type::DELETE);
                let op = op.path_param("working_hours_type_id", working_hours_type_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                working_hours_type_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::working_hours_type::GET);
                let op = op.path_param("working_hours_type_id", working_hours_type_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::working_hours_type::LIST);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                working_hours_type_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v1::working_hours_type::PATCH);
                let op = op.path_param("working_hours_type_id", working_hours_type_id.into());
                op
            }
        }
    }

    pub mod v2 {
        use super::*;
        pub mod approval_groups {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                process_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::approval_groups::GET);
                let op = op.path_param("process_id", process_id.into());
                op
            }

            pub fn open_query_department_change_list_by_ids<'a>(
                client: &'a Client,
            ) -> OperationBuilder<'a> {
                let op = client.operation(
                    ops::corehr::v2::approval_groups::OPEN_QUERY_DEPARTMENT_CHANGE_LIST_BY_IDS,
                );
                op
            }

            pub fn open_query_job_change_list_by_ids<'a>(
                client: &'a Client,
            ) -> OperationBuilder<'a> {
                let op = client
                    .operation(ops::corehr::v2::approval_groups::OPEN_QUERY_JOB_CHANGE_LIST_BY_IDS);
                op
            }

            pub fn open_query_position_change_list_by_ids<'a>(
                client: &'a Client,
            ) -> OperationBuilder<'a> {
                let op = client.operation(
                    ops::corehr::v2::approval_groups::OPEN_QUERY_POSITION_CHANGE_LIST_BY_IDS,
                );
                op
            }
        }

        pub mod approver {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::approver::LIST);
                op
            }
        }

        pub mod basic_info_bank {
            use super::*;
            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::basic_info_bank::SEARCH);
                op
            }
        }

        pub mod basic_info_bank_branch {
            use super::*;
            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::basic_info_bank_branch::SEARCH);
                op
            }
        }

        pub mod basic_info_city {
            use super::*;
            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::basic_info_city::SEARCH);
                op
            }
        }

        pub mod basic_info_country_region {
            use super::*;
            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::basic_info_country_region::SEARCH);
                op
            }
        }

        pub mod basic_info_country_region_subdivision {
            use super::*;
            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client
                    .operation(ops::corehr::v2::basic_info_country_region_subdivision::SEARCH);
                op
            }
        }

        pub mod basic_info_currency {
            use super::*;
            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::basic_info_currency::SEARCH);
                op
            }
        }

        pub mod basic_info_district {
            use super::*;
            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::basic_info_district::SEARCH);
                op
            }
        }

        pub mod basic_info_language {
            use super::*;
            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::basic_info_language::SEARCH);
                op
            }
        }

        pub mod basic_info_nationality {
            use super::*;
            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::basic_info_nationality::SEARCH);
                op
            }
        }

        pub mod basic_info_time_zone {
            use super::*;
            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::basic_info_time_zone::SEARCH);
                op
            }
        }

        pub mod bp {
            use super::*;
            pub fn get_by_department<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::bp::GET_BY_DEPARTMENT);
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::bp::LIST);
                op
            }
        }

        pub mod company {
            use super::*;
            pub fn active<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::company::ACTIVE);
                op
            }

            pub fn batch_get<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::company::BATCH_GET);
                op
            }

            pub fn query_recent_change<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::company::QUERY_RECENT_CHANGE);
                op
            }
        }

        pub mod contract {
            use super::*;
            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::contract::SEARCH);
                op
            }
        }

        pub mod cost_allocation {
            use super::*;
            pub fn batch_query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::cost_allocation::BATCH_QUERY);
                op
            }

            pub fn create_version<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::cost_allocation::CREATE_VERSION);
                op
            }

            pub fn remove_version<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::cost_allocation::REMOVE_VERSION);
                op
            }

            pub fn update_version<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::cost_allocation::UPDATE_VERSION);
                op
            }
        }

        pub mod cost_center {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::cost_center::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                cost_center_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::cost_center::DELETE);
                let op = op.path_param("cost_center_id", cost_center_id.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                cost_center_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::cost_center::PATCH);
                let op = op.path_param("cost_center_id", cost_center_id.into());
                op
            }

            pub fn query_recent_change<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::cost_center::QUERY_RECENT_CHANGE);
                op
            }

            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::cost_center::SEARCH);
                op
            }
        }

        pub mod cost_center_version {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                cost_center_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::cost_center_version::CREATE);
                let op = op.path_param("cost_center_id", cost_center_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                cost_center_id: impl Into<String>,
                version_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::cost_center_version::DELETE);
                let op = op
                    .path_param("cost_center_id", cost_center_id.into())
                    .path_param("version_id", version_id.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                cost_center_id: impl Into<String>,
                version_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::cost_center_version::PATCH);
                let op = op
                    .path_param("cost_center_id", cost_center_id.into())
                    .path_param("version_id", version_id.into());
                op
            }
        }

        pub mod custom_org {
            use super::*;
            pub fn active<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::custom_org::ACTIVE);
                op
            }

            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::custom_org::CREATE);
                op
            }

            pub fn delete_org<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::custom_org::DELETE_ORG);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                org_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::custom_org::PATCH);
                let op = op.path_param("org_id", org_id.into());
                op
            }

            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::custom_org::QUERY);
                op
            }

            pub fn query_recent_change<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::custom_org::QUERY_RECENT_CHANGE);
                op
            }

            pub fn update_rule<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::custom_org::UPDATE_RULE);
                op
            }
        }

        pub mod default_cost_center {
            use super::*;
            pub fn batch_query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::default_cost_center::BATCH_QUERY);
                op
            }

            pub fn create_version<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::default_cost_center::CREATE_VERSION);
                op
            }

            pub fn remove_version<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::default_cost_center::REMOVE_VERSION);
                op
            }

            pub fn update_version<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::default_cost_center::UPDATE_VERSION);
                op
            }
        }

        pub mod department {
            use super::*;
            pub fn batch_get<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::department::BATCH_GET);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                department_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::department::DELETE);
                let op = op.path_param("department_id", department_id.into());
                op
            }

            pub fn parents<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::department::PARENTS);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                department_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::department::PATCH);
                let op = op.path_param("department_id", department_id.into());
                op
            }

            pub fn query_multi_timeline<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::department::QUERY_MULTI_TIMELINE);
                op
            }

            pub fn query_operation_logs<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::department::QUERY_OPERATION_LOGS);
                op
            }

            pub fn query_recent_change<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::department::QUERY_RECENT_CHANGE);
                op
            }

            pub fn query_timeline<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::department::QUERY_TIMELINE);
                op
            }

            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::department::SEARCH);
                op
            }

            pub fn tree<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::department::TREE);
                op
            }
        }

        pub mod draft {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                draft_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::draft::GET);
                let op = op.path_param("draft_id", draft_id.into());
                op
            }
        }

        pub mod employee {
            use super::*;
            pub fn batch_get<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::employee::BATCH_GET);
                op
            }

            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::employee::CREATE);
                op
            }

            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::employee::SEARCH);
                op
            }
        }

        pub mod employees_additional_job {
            use super::*;
            pub fn batch<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::employees_additional_job::BATCH);
                op
            }

            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::employees_additional_job::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                additional_job_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::employees_additional_job::DELETE);
                let op = op.path_param("additional_job_id", additional_job_id.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                additional_job_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::employees_additional_job::PATCH);
                let op = op.path_param("additional_job_id", additional_job_id.into());
                op
            }
        }

        pub mod employees_bp {
            use super::*;
            pub fn batch_get<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::employees_bp::BATCH_GET);
                op
            }
        }

        pub mod employees_international_assignment {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op =
                    client.operation(ops::corehr::v2::employees_international_assignment::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                international_assignment_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op =
                    client.operation(ops::corehr::v2::employees_international_assignment::DELETE);
                let op = op.path_param(
                    "international_assignment_id",
                    international_assignment_id.into(),
                );
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op =
                    client.operation(ops::corehr::v2::employees_international_assignment::LIST);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                international_assignment_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op =
                    client.operation(ops::corehr::v2::employees_international_assignment::PATCH);
                let op = op.path_param(
                    "international_assignment_id",
                    international_assignment_id.into(),
                );
                op
            }
        }

        pub mod employees_job_data {
            use super::*;
            pub fn batch_get<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::employees_job_data::BATCH_GET);
                op
            }

            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::employees_job_data::QUERY);
                op
            }
        }

        pub mod enum_ {
            use super::*;
            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::enum_::SEARCH);
                op
            }
        }

        pub mod job {
            use super::*;
            pub fn batch_get<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::job::BATCH_GET);
                op
            }

            pub fn get<'a>(client: &'a Client, job_id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::job::GET);
                let op = op.path_param("job_id", job_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::job::LIST);
                op
            }

            pub fn query_multi_timeline<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::job::QUERY_MULTI_TIMELINE);
                op
            }

            pub fn query_recent_change<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::job::QUERY_RECENT_CHANGE);
                op
            }
        }

        pub mod job_change {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::job_change::CREATE);
                op
            }

            pub fn revoke<'a>(
                client: &'a Client,
                job_change_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::job_change::REVOKE);
                let op = op.path_param("job_change_id", job_change_id.into());
                op
            }

            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::job_change::SEARCH);
                op
            }
        }

        pub mod job_family {
            use super::*;
            pub fn batch_get<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::job_family::BATCH_GET);
                op
            }

            pub fn query_multi_timeline<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::job_family::QUERY_MULTI_TIMELINE);
                op
            }

            pub fn query_recent_change<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::job_family::QUERY_RECENT_CHANGE);
                op
            }
        }

        pub mod job_grade {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::job_grade::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                job_grade_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::job_grade::DELETE);
                let op = op.path_param("job_grade_id", job_grade_id.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                job_grade_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::job_grade::PATCH);
                let op = op.path_param("job_grade_id", job_grade_id.into());
                op
            }

            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::job_grade::QUERY);
                op
            }

            pub fn query_recent_change<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::job_grade::QUERY_RECENT_CHANGE);
                op
            }
        }

        pub mod job_level {
            use super::*;
            pub fn batch_get<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::job_level::BATCH_GET);
                op
            }

            pub fn query_recent_change<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::job_level::QUERY_RECENT_CHANGE);
                op
            }
        }

        pub mod location {
            use super::*;
            pub fn active<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::location::ACTIVE);
                op
            }

            pub fn batch_get<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::location::BATCH_GET);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                location_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::location::PATCH);
                let op = op.path_param("location_id", location_id.into());
                op
            }

            pub fn query_recent_change<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::location::QUERY_RECENT_CHANGE);
                op
            }
        }

        pub mod location_address {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                location_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::location_address::CREATE);
                let op = op.path_param("location_id", location_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                location_id: impl Into<String>,
                address_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::location_address::DELETE);
                let op = op
                    .path_param("location_id", location_id.into())
                    .path_param("address_id", address_id.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                location_id: impl Into<String>,
                address_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::location_address::PATCH);
                let op = op
                    .path_param("location_id", location_id.into())
                    .path_param("address_id", address_id.into());
                op
            }
        }

        pub mod offboarding {
            use super::*;
            pub fn edit<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::offboarding::EDIT);
                op
            }

            pub fn revoke<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::offboarding::REVOKE);
                op
            }

            pub fn submit_v2<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::offboarding::SUBMIT_V2);
                op
            }
        }

        pub mod pathway {
            use super::*;
            pub fn active<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::pathway::ACTIVE);
                op
            }

            pub fn batch_get<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::pathway::BATCH_GET);
                op
            }

            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::pathway::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                pathway_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::pathway::DELETE);
                let op = op.path_param("pathway_id", pathway_id.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                pathway_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::pathway::PATCH);
                let op = op.path_param("pathway_id", pathway_id.into());
                op
            }
        }

        pub mod person {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::person::CREATE);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                person_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::person::PATCH);
                let op = op.path_param("person_id", person_id.into());
                op
            }
        }

        pub mod position {
            use super::*;
            pub fn active<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::position::ACTIVE);
                op
            }

            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::position::CREATE);
                op
            }

            pub fn del_position<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::position::DEL_POSITION);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                position_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::position::PATCH);
                let op = op.path_param("position_id", position_id.into());
                op
            }

            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::position::QUERY);
                op
            }

            pub fn query_recent_change<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::position::QUERY_RECENT_CHANGE);
                op
            }
        }

        pub mod pre_hire {
            use super::*;
            pub fn complete<'a>(
                client: &'a Client,
                pre_hire_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::pre_hire::COMPLETE);
                let op = op.path_param("pre_hire_id", pre_hire_id.into());
                op
            }

            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::pre_hire::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                pre_hire_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::pre_hire::DELETE);
                let op = op.path_param("pre_hire_id", pre_hire_id.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                pre_hire_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::pre_hire::PATCH);
                let op = op.path_param("pre_hire_id", pre_hire_id.into());
                op
            }

            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::pre_hire::QUERY);
                op
            }

            pub fn restore_flow_instance<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::pre_hire::RESTORE_FLOW_INSTANCE);
                op
            }

            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::pre_hire::SEARCH);
                op
            }

            pub fn transform_onboarding_task<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::pre_hire::TRANSFORM_ONBOARDING_TASK);
                op
            }

            pub fn transit_task<'a>(
                client: &'a Client,
                pre_hire_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::pre_hire::TRANSIT_TASK);
                let op = op.path_param("pre_hire_id", pre_hire_id.into());
                op
            }

            pub fn withdraw_onboarding<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::pre_hire::WITHDRAW_ONBOARDING);
                op
            }
        }

        pub mod probation {
            use super::*;
            pub fn enable_disable_assessment<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::probation::ENABLE_DISABLE_ASSESSMENT);
                op
            }

            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::probation::SEARCH);
                op
            }

            pub fn submit<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::probation::SUBMIT);
                op
            }

            pub fn withdraw<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::probation::WITHDRAW);
                op
            }
        }

        pub mod probation_assessment {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::probation_assessment::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                assessment_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::probation_assessment::DELETE);
                let op = op.path_param("assessment_id", assessment_id.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                assessment_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::probation_assessment::PATCH);
                let op = op.path_param("assessment_id", assessment_id.into());
                op
            }
        }

        pub mod process {
            use super::*;
            pub fn flow_variable_data<'a>(
                client: &'a Client,
                process_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::process::FLOW_VARIABLE_DATA);
                let op = op.path_param("process_id", process_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                process_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::process::GET);
                let op = op.path_param("process_id", process_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::process::LIST);
                op
            }
        }

        pub mod process_approver {
            use super::*;
            pub fn update<'a>(
                client: &'a Client,
                process_id: impl Into<String>,
                approver_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::process_approver::UPDATE);
                let op = op
                    .path_param("process_id", process_id.into())
                    .path_param("approver_id", approver_id.into());
                op
            }
        }

        pub mod process_extra {
            use super::*;
            pub fn update<'a>(
                client: &'a Client,
                process_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::process_extra::UPDATE);
                let op = op.path_param("process_id", process_id.into());
                op
            }
        }

        pub mod process_form_variable_data {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                process_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::process_form_variable_data::GET);
                let op = op.path_param("process_id", process_id.into());
                op
            }
        }

        pub mod process_revoke {
            use super::*;
            pub fn update<'a>(
                client: &'a Client,
                process_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::process_revoke::UPDATE);
                let op = op.path_param("process_id", process_id.into());
                op
            }
        }

        pub mod process_transfer {
            use super::*;
            pub fn update<'a>(
                client: &'a Client,
                process_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::process_transfer::UPDATE);
                let op = op.path_param("process_id", process_id.into());
                op
            }
        }

        pub mod process_withdraw {
            use super::*;
            pub fn update<'a>(
                client: &'a Client,
                process_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::process_withdraw::UPDATE);
                let op = op.path_param("process_id", process_id.into());
                op
            }
        }

        pub mod report_detail_row {
            use super::*;
            pub fn batch_delete<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::report_detail_row::BATCH_DELETE);
                op
            }

            pub fn batch_save<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::report_detail_row::BATCH_SAVE);
                op
            }
        }

        pub mod signature_file {
            use super::*;
            pub fn download<'a>(
                client: &'a Client,
                signature_file_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::signature_file::DOWNLOAD);
                let op = op.path_param("signature_file_id", signature_file_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::signature_file::LIST);
                op
            }

            pub fn list_by_biz_id<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::signature_file::LIST_BY_BIZ_ID);
                op
            }

            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::signature_file::QUERY);
                op
            }

            pub fn terminate<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::signature_file::TERMINATE);
                op
            }
        }

        pub mod signature_node {
            use super::*;
            pub fn list_by_file_id<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::signature_node::LIST_BY_FILE_ID);
                op
            }
        }

        pub mod signature_template {
            use super::*;
            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::signature_template::SEARCH);
                op
            }
        }

        pub mod signature_template_info_with_thumbnail {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op =
                    client.operation(ops::corehr::v2::signature_template_info_with_thumbnail::LIST);
                op
            }
        }

        pub mod workforce_plan {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::workforce_plan::LIST);
                op
            }
        }

        pub mod workforce_plan_detail {
            use super::*;
            pub fn batch<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::workforce_plan_detail::BATCH);
                op
            }

            pub fn batch_v2<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::workforce_plan_detail::BATCH_V2);
                op
            }
        }

        pub mod workforce_plan_detail_row {
            use super::*;
            pub fn batch_delete<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::workforce_plan_detail_row::BATCH_DELETE);
                op
            }

            pub fn batch_save<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::corehr::v2::workforce_plan_detail_row::BATCH_SAVE);
                op
            }
        }
    }
}

pub mod directory {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod collaboration_rule {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::directory::v1::collaboration_rule::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                collaboration_rule_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::directory::v1::collaboration_rule::DELETE);
                let op = op.path_param("collaboration_rule_id", collaboration_rule_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::directory::v1::collaboration_rule::LIST);
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                collaboration_rule_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::directory::v1::collaboration_rule::UPDATE);
                let op = op.path_param("collaboration_rule_id", collaboration_rule_id.into());
                op
            }
        }

        pub mod collaboration_tenant {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::directory::v1::collaboration_tenant::LIST);
                op
            }
        }

        pub mod collboration_share_entity {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::directory::v1::collboration_share_entity::LIST);
                op
            }
        }

        pub mod department {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::directory::v1::department::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                department_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::directory::v1::department::DELETE);
                let op = op.path_param("department_id", department_id.into());
                op
            }

            pub fn filter<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::directory::v1::department::FILTER);
                op
            }

            pub fn mget<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::directory::v1::department::MGET);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                department_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::directory::v1::department::PATCH);
                let op = op.path_param("department_id", department_id.into());
                op
            }

            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::directory::v1::department::SEARCH);
                op
            }
        }

        pub mod employee {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::directory::v1::employee::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                employee_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::directory::v1::employee::DELETE);
                let op = op.path_param("employee_id", employee_id.into());
                op
            }

            pub fn filter<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::directory::v1::employee::FILTER);
                op
            }

            pub fn mget<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::directory::v1::employee::MGET);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                employee_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::directory::v1::employee::PATCH);
                let op = op.path_param("employee_id", employee_id.into());
                op
            }

            pub fn regular<'a>(
                client: &'a Client,
                employee_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::directory::v1::employee::REGULAR);
                let op = op.path_param("employee_id", employee_id.into());
                op
            }

            pub fn resurrect<'a>(
                client: &'a Client,
                employee_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::directory::v1::employee::RESURRECT);
                let op = op.path_param("employee_id", employee_id.into());
                op
            }

            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::directory::v1::employee::SEARCH);
                op
            }

            pub fn to_be_resigned<'a>(
                client: &'a Client,
                employee_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::directory::v1::employee::TO_BE_RESIGNED);
                let op = op.path_param("employee_id", employee_id.into());
                op
            }
        }
    }
}

pub mod docs {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod content {
            use super::*;
            pub fn get<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::docs::v1::content::GET);
                op
            }
        }
    }
}

pub mod document_ai {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod bank_card {
            use super::*;
            pub fn recognize<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::document_ai::v1::bank_card::RECOGNIZE);
                op
            }
        }

        pub mod business_card {
            use super::*;
            pub fn recognize<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::document_ai::v1::business_card::RECOGNIZE);
                op
            }
        }

        pub mod business_license {
            use super::*;
            pub fn recognize<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::document_ai::v1::business_license::RECOGNIZE);
                op
            }
        }

        pub mod chinese_passport {
            use super::*;
            pub fn recognize<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::document_ai::v1::chinese_passport::RECOGNIZE);
                op
            }
        }

        pub mod contract {
            use super::*;
            pub fn field_extraction<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::document_ai::v1::contract::FIELD_EXTRACTION);
                op
            }
        }

        pub mod driving_license {
            use super::*;
            pub fn recognize<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::document_ai::v1::driving_license::RECOGNIZE);
                op
            }
        }

        pub mod food_manage_license {
            use super::*;
            pub fn recognize<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::document_ai::v1::food_manage_license::RECOGNIZE);
                op
            }
        }

        pub mod food_produce_license {
            use super::*;
            pub fn recognize<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::document_ai::v1::food_produce_license::RECOGNIZE);
                op
            }
        }

        pub mod health_certificate {
            use super::*;
            pub fn recognize<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::document_ai::v1::health_certificate::RECOGNIZE);
                op
            }
        }

        pub mod hkm_mainland_travel_permit {
            use super::*;
            pub fn recognize<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op =
                    client.operation(ops::document_ai::v1::hkm_mainland_travel_permit::RECOGNIZE);
                op
            }
        }

        pub mod id_card {
            use super::*;
            pub fn recognize<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::document_ai::v1::id_card::RECOGNIZE);
                op
            }
        }

        pub mod resume {
            use super::*;
            pub fn parse<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::document_ai::v1::resume::PARSE);
                op
            }
        }

        pub mod taxi_invoice {
            use super::*;
            pub fn recognize<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::document_ai::v1::taxi_invoice::RECOGNIZE);
                op
            }
        }

        pub mod train_invoice {
            use super::*;
            pub fn recognize<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::document_ai::v1::train_invoice::RECOGNIZE);
                op
            }
        }

        pub mod tw_mainland_travel_permit {
            use super::*;
            pub fn recognize<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op =
                    client.operation(ops::document_ai::v1::tw_mainland_travel_permit::RECOGNIZE);
                op
            }
        }

        pub mod vat_invoice {
            use super::*;
            pub fn recognize<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::document_ai::v1::vat_invoice::RECOGNIZE);
                op
            }
        }

        pub mod vehicle_invoice {
            use super::*;
            pub fn recognize<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::document_ai::v1::vehicle_invoice::RECOGNIZE);
                op
            }
        }

        pub mod vehicle_license {
            use super::*;
            pub fn recognize<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::document_ai::v1::vehicle_license::RECOGNIZE);
                op
            }
        }
    }
}

pub mod docx {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod chat_announcement {
            use super::*;
            pub fn get<'a>(client: &'a Client, chat_id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::docx::v1::chat_announcement::GET);
                let op = op.path_param("chat_id", chat_id.into());
                op
            }
        }

        pub mod chat_announcement_block {
            use super::*;
            pub fn batch_update<'a>(
                client: &'a Client,
                chat_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::docx::v1::chat_announcement_block::BATCH_UPDATE);
                let op = op.path_param("chat_id", chat_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                chat_id: impl Into<String>,
                block_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::docx::v1::chat_announcement_block::GET);
                let op = op
                    .path_param("chat_id", chat_id.into())
                    .path_param("block_id", block_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                chat_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::docx::v1::chat_announcement_block::LIST);
                let op = op.path_param("chat_id", chat_id.into());
                op
            }
        }

        pub mod chat_announcement_block_children {
            use super::*;
            pub fn batch_delete<'a>(
                client: &'a Client,
                chat_id: impl Into<String>,
                block_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op =
                    client.operation(ops::docx::v1::chat_announcement_block_children::BATCH_DELETE);
                let op = op
                    .path_param("chat_id", chat_id.into())
                    .path_param("block_id", block_id.into());
                op
            }

            pub fn create<'a>(
                client: &'a Client,
                chat_id: impl Into<String>,
                block_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::docx::v1::chat_announcement_block_children::CREATE);
                let op = op
                    .path_param("chat_id", chat_id.into())
                    .path_param("block_id", block_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                chat_id: impl Into<String>,
                block_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::docx::v1::chat_announcement_block_children::GET);
                let op = op
                    .path_param("chat_id", chat_id.into())
                    .path_param("block_id", block_id.into());
                op
            }
        }

        pub mod document {
            use super::*;
            pub fn convert<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::docx::v1::document::CONVERT);
                op
            }

            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::docx::v1::document::CREATE);
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                document_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::docx::v1::document::GET);
                let op = op.path_param("document_id", document_id.into());
                op
            }

            pub fn raw_content<'a>(
                client: &'a Client,
                document_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::docx::v1::document::RAW_CONTENT);
                let op = op.path_param("document_id", document_id.into());
                op
            }
        }

        pub mod document_block {
            use super::*;
            pub fn batch_update<'a>(
                client: &'a Client,
                document_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::docx::v1::document_block::BATCH_UPDATE);
                let op = op.path_param("document_id", document_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                document_id: impl Into<String>,
                block_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::docx::v1::document_block::GET);
                let op = op
                    .path_param("document_id", document_id.into())
                    .path_param("block_id", block_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                document_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::docx::v1::document_block::LIST);
                let op = op.path_param("document_id", document_id.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                document_id: impl Into<String>,
                block_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::docx::v1::document_block::PATCH);
                let op = op
                    .path_param("document_id", document_id.into())
                    .path_param("block_id", block_id.into());
                op
            }
        }

        pub mod document_block_children {
            use super::*;
            pub fn batch_delete<'a>(
                client: &'a Client,
                document_id: impl Into<String>,
                block_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::docx::v1::document_block_children::BATCH_DELETE);
                let op = op
                    .path_param("document_id", document_id.into())
                    .path_param("block_id", block_id.into());
                op
            }

            pub fn create<'a>(
                client: &'a Client,
                document_id: impl Into<String>,
                block_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::docx::v1::document_block_children::CREATE);
                let op = op
                    .path_param("document_id", document_id.into())
                    .path_param("block_id", block_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                document_id: impl Into<String>,
                block_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::docx::v1::document_block_children::GET);
                let op = op
                    .path_param("document_id", document_id.into())
                    .path_param("block_id", block_id.into());
                op
            }
        }

        pub mod document_block_descendant {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                document_id: impl Into<String>,
                block_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::docx::v1::document_block_descendant::CREATE);
                let op = op
                    .path_param("document_id", document_id.into())
                    .path_param("block_id", block_id.into());
                op
            }
        }
    }
}

pub mod drive {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod export_task {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::export_task::CREATE);
                op
            }

            pub fn download<'a>(
                client: &'a Client,
                file_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::export_task::DOWNLOAD);
                let op = op.path_param("file_token", file_token.into());
                op
            }

            pub fn get<'a>(client: &'a Client, ticket: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::export_task::GET);
                let op = op.path_param("ticket", ticket.into());
                op
            }
        }

        pub mod file {
            use super::*;
            pub fn copy<'a>(
                client: &'a Client,
                file_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::file::COPY);
                let op = op.path_param("file_token", file_token.into());
                op
            }

            pub fn create_folder<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::file::CREATE_FOLDER);
                op
            }

            pub fn create_shortcut<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::file::CREATE_SHORTCUT);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                file_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::file::DELETE);
                let op = op.path_param("file_token", file_token.into());
                op
            }

            pub fn delete_subscribe<'a>(
                client: &'a Client,
                file_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::file::DELETE_SUBSCRIBE);
                let op = op.path_param("file_token", file_token.into());
                op
            }

            pub fn download<'a>(
                client: &'a Client,
                file_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::file::DOWNLOAD);
                let op = op.path_param("file_token", file_token.into());
                op
            }

            pub fn get_subscribe<'a>(
                client: &'a Client,
                file_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::file::GET_SUBSCRIBE);
                let op = op.path_param("file_token", file_token.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::file::LIST);
                op
            }

            pub fn move_<'a>(
                client: &'a Client,
                file_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::file::MOVE);
                let op = op.path_param("file_token", file_token.into());
                op
            }

            pub fn subscribe<'a>(
                client: &'a Client,
                file_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::file::SUBSCRIBE);
                let op = op.path_param("file_token", file_token.into());
                op
            }

            pub fn task_check<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::file::TASK_CHECK);
                op
            }

            pub fn upload_all<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::file::UPLOAD_ALL);
                op
            }

            pub fn upload_finish<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::file::UPLOAD_FINISH);
                op
            }

            pub fn upload_part<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::file::UPLOAD_PART);
                op
            }

            pub fn upload_prepare<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::file::UPLOAD_PREPARE);
                op
            }
        }

        pub mod file_comment {
            use super::*;
            pub fn batch_query<'a>(
                client: &'a Client,
                file_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::file_comment::BATCH_QUERY);
                let op = op.path_param("file_token", file_token.into());
                op
            }

            pub fn create<'a>(
                client: &'a Client,
                file_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::file_comment::CREATE);
                let op = op.path_param("file_token", file_token.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                file_token: impl Into<String>,
                comment_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::file_comment::GET);
                let op = op
                    .path_param("file_token", file_token.into())
                    .path_param("comment_id", comment_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                file_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::file_comment::LIST);
                let op = op.path_param("file_token", file_token.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                file_token: impl Into<String>,
                comment_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::file_comment::PATCH);
                let op = op
                    .path_param("file_token", file_token.into())
                    .path_param("comment_id", comment_id.into());
                op
            }
        }

        pub mod file_comment_reply {
            use super::*;
            pub fn delete<'a>(
                client: &'a Client,
                file_token: impl Into<String>,
                comment_id: impl Into<String>,
                reply_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::file_comment_reply::DELETE);
                let op = op
                    .path_param("file_token", file_token.into())
                    .path_param("comment_id", comment_id.into())
                    .path_param("reply_id", reply_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                file_token: impl Into<String>,
                comment_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::file_comment_reply::LIST);
                let op = op
                    .path_param("file_token", file_token.into())
                    .path_param("comment_id", comment_id.into());
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                file_token: impl Into<String>,
                comment_id: impl Into<String>,
                reply_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::file_comment_reply::UPDATE);
                let op = op
                    .path_param("file_token", file_token.into())
                    .path_param("comment_id", comment_id.into())
                    .path_param("reply_id", reply_id.into());
                op
            }
        }

        pub mod file_statistics {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                file_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::file_statistics::GET);
                let op = op.path_param("file_token", file_token.into());
                op
            }
        }

        pub mod file_subscription {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                file_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::file_subscription::CREATE);
                let op = op.path_param("file_token", file_token.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                file_token: impl Into<String>,
                subscription_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::file_subscription::GET);
                let op = op
                    .path_param("file_token", file_token.into())
                    .path_param("subscription_id", subscription_id.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                file_token: impl Into<String>,
                subscription_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::file_subscription::PATCH);
                let op = op
                    .path_param("file_token", file_token.into())
                    .path_param("subscription_id", subscription_id.into());
                op
            }
        }

        pub mod file_version {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                file_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::file_version::CREATE);
                let op = op.path_param("file_token", file_token.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                file_token: impl Into<String>,
                version_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::file_version::DELETE);
                let op = op
                    .path_param("file_token", file_token.into())
                    .path_param("version_id", version_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                file_token: impl Into<String>,
                version_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::file_version::GET);
                let op = op
                    .path_param("file_token", file_token.into())
                    .path_param("version_id", version_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                file_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::file_version::LIST);
                let op = op.path_param("file_token", file_token.into());
                op
            }
        }

        pub mod file_view_record {
            use super::*;
            pub fn list<'a>(
                client: &'a Client,
                file_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::file_view_record::LIST);
                let op = op.path_param("file_token", file_token.into());
                op
            }
        }

        pub mod import_task {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::import_task::CREATE);
                op
            }

            pub fn get<'a>(client: &'a Client, ticket: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::import_task::GET);
                let op = op.path_param("ticket", ticket.into());
                op
            }
        }

        pub mod media {
            use super::*;
            pub fn batch_get_tmp_download_url<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::media::BATCH_GET_TMP_DOWNLOAD_URL);
                op
            }

            pub fn download<'a>(
                client: &'a Client,
                file_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::media::DOWNLOAD);
                let op = op.path_param("file_token", file_token.into());
                op
            }

            pub fn upload_all<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::media::UPLOAD_ALL);
                op
            }

            pub fn upload_finish<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::media::UPLOAD_FINISH);
                op
            }

            pub fn upload_part<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::media::UPLOAD_PART);
                op
            }

            pub fn upload_prepare<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::media::UPLOAD_PREPARE);
                op
            }
        }

        pub mod meta {
            use super::*;
            pub fn batch_query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::meta::BATCH_QUERY);
                op
            }
        }

        pub mod permission_member {
            use super::*;
            pub fn auth<'a>(client: &'a Client, token: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::permission_member::AUTH);
                let op = op.path_param("token", token.into());
                op
            }

            pub fn batch_create<'a>(
                client: &'a Client,
                token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::permission_member::BATCH_CREATE);
                let op = op.path_param("token", token.into());
                op
            }

            pub fn create<'a>(
                client: &'a Client,
                token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::permission_member::CREATE);
                let op = op.path_param("token", token.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                token: impl Into<String>,
                member_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::permission_member::DELETE);
                let op = op
                    .path_param("token", token.into())
                    .path_param("member_id", member_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client, token: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::permission_member::LIST);
                let op = op.path_param("token", token.into());
                op
            }

            pub fn transfer_owner<'a>(
                client: &'a Client,
                token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::permission_member::TRANSFER_OWNER);
                let op = op.path_param("token", token.into());
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                token: impl Into<String>,
                member_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::permission_member::UPDATE);
                let op = op
                    .path_param("token", token.into())
                    .path_param("member_id", member_id.into());
                op
            }
        }

        pub mod permission_public {
            use super::*;
            pub fn get<'a>(client: &'a Client, token: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::permission_public::GET);
                let op = op.path_param("token", token.into());
                op
            }

            pub fn patch<'a>(client: &'a Client, token: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::permission_public::PATCH);
                let op = op.path_param("token", token.into());
                op
            }
        }

        pub mod permission_public_password {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::permission_public_password::CREATE);
                let op = op.path_param("token", token.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::permission_public_password::DELETE);
                let op = op.path_param("token", token.into());
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v1::permission_public_password::UPDATE);
                let op = op.path_param("token", token.into());
                op
            }
        }
    }

    pub mod v2 {
        use super::*;
        pub mod file_like {
            use super::*;
            pub fn list<'a>(
                client: &'a Client,
                file_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v2::file_like::LIST);
                let op = op.path_param("file_token", file_token.into());
                op
            }
        }

        pub mod permission_public {
            use super::*;
            pub fn get<'a>(client: &'a Client, token: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v2::permission_public::GET);
                let op = op.path_param("token", token.into());
                op
            }

            pub fn patch<'a>(client: &'a Client, token: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::drive::v2::permission_public::PATCH);
                let op = op.path_param("token", token.into());
                op
            }
        }
    }
}

pub mod ehr {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod attachment {
            use super::*;
            pub fn get<'a>(client: &'a Client, token: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::ehr::v1::attachment::GET);
                let op = op.path_param("token", token.into());
                op
            }
        }

        pub mod employee {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::ehr::v1::employee::LIST);
                op
            }
        }
    }
}

pub mod event {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod outbound_ip {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::event::v1::outbound_ip::LIST);
                op
            }
        }
    }
}

pub mod helpdesk {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod agent {
            use super::*;
            pub fn agent_email<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::agent::AGENT_EMAIL);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                agent_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::agent::PATCH);
                let op = op.path_param("agent_id", agent_id.into());
                op
            }
        }

        pub mod agent_schedule {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::agent_schedule::CREATE);
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::agent_schedule::LIST);
                op
            }
        }

        pub mod agent_schedules {
            use super::*;
            pub fn delete<'a>(
                client: &'a Client,
                agent_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::agent_schedules::DELETE);
                let op = op.path_param("agent_id", agent_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                agent_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::agent_schedules::GET);
                let op = op.path_param("agent_id", agent_id.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                agent_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::agent_schedules::PATCH);
                let op = op.path_param("agent_id", agent_id.into());
                op
            }
        }

        pub mod agent_skill {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::agent_skill::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                agent_skill_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::agent_skill::DELETE);
                let op = op.path_param("agent_skill_id", agent_skill_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                agent_skill_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::agent_skill::GET);
                let op = op.path_param("agent_skill_id", agent_skill_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::agent_skill::LIST);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                agent_skill_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::agent_skill::PATCH);
                let op = op.path_param("agent_skill_id", agent_skill_id.into());
                op
            }
        }

        pub mod agent_skill_rule {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::agent_skill_rule::LIST);
                op
            }
        }

        pub mod bot_message {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::bot_message::CREATE);
                op
            }
        }

        pub mod category {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::category::CREATE);
                op
            }

            pub fn delete<'a>(client: &'a Client, id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::category::DELETE);
                let op = op.path_param("id", id.into());
                op
            }

            pub fn get<'a>(client: &'a Client, id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::category::GET);
                let op = op.path_param("id", id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::category::LIST);
                op
            }

            pub fn patch<'a>(client: &'a Client, id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::category::PATCH);
                let op = op.path_param("id", id.into());
                op
            }
        }

        pub mod event {
            use super::*;
            pub fn subscribe<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::event::SUBSCRIBE);
                op
            }

            pub fn unsubscribe<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::event::UNSUBSCRIBE);
                op
            }
        }

        pub mod faq {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::faq::CREATE);
                op
            }

            pub fn delete<'a>(client: &'a Client, id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::faq::DELETE);
                let op = op.path_param("id", id.into());
                op
            }

            pub fn faq_image<'a>(
                client: &'a Client,
                id: impl Into<String>,
                image_key: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::faq::FAQ_IMAGE);
                let op = op
                    .path_param("id", id.into())
                    .path_param("image_key", image_key.into());
                op
            }

            pub fn get<'a>(client: &'a Client, id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::faq::GET);
                let op = op.path_param("id", id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::faq::LIST);
                op
            }

            pub fn patch<'a>(client: &'a Client, id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::faq::PATCH);
                let op = op.path_param("id", id.into());
                op
            }

            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::faq::SEARCH);
                op
            }
        }

        pub mod notification {
            use super::*;
            pub fn cancel_approve<'a>(
                client: &'a Client,
                notification_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::notification::CANCEL_APPROVE);
                let op = op.path_param("notification_id", notification_id.into());
                op
            }

            pub fn cancel_send<'a>(
                client: &'a Client,
                notification_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::notification::CANCEL_SEND);
                let op = op.path_param("notification_id", notification_id.into());
                op
            }

            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::notification::CREATE);
                op
            }

            pub fn execute_send<'a>(
                client: &'a Client,
                notification_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::notification::EXECUTE_SEND);
                let op = op.path_param("notification_id", notification_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                notification_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::notification::GET);
                let op = op.path_param("notification_id", notification_id.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                notification_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::notification::PATCH);
                let op = op.path_param("notification_id", notification_id.into());
                op
            }

            pub fn preview<'a>(
                client: &'a Client,
                notification_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::notification::PREVIEW);
                let op = op.path_param("notification_id", notification_id.into());
                op
            }

            pub fn submit_approve<'a>(
                client: &'a Client,
                notification_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::notification::SUBMIT_APPROVE);
                let op = op.path_param("notification_id", notification_id.into());
                op
            }
        }

        pub mod ticket {
            use super::*;
            pub fn answer_user_query<'a>(
                client: &'a Client,
                ticket_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::ticket::ANSWER_USER_QUERY);
                let op = op.path_param("ticket_id", ticket_id.into());
                op
            }

            pub fn customized_fields<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::ticket::CUSTOMIZED_FIELDS);
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                ticket_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::ticket::GET);
                let op = op.path_param("ticket_id", ticket_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::ticket::LIST);
                op
            }

            pub fn start_service<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::ticket::START_SERVICE);
                op
            }

            pub fn ticket_image<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::ticket::TICKET_IMAGE);
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                ticket_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::ticket::UPDATE);
                let op = op.path_param("ticket_id", ticket_id.into());
                op
            }
        }

        pub mod ticket_customized_field {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::ticket_customized_field::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                ticket_customized_field_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::ticket_customized_field::DELETE);
                let op = op.path_param(
                    "ticket_customized_field_id",
                    ticket_customized_field_id.into(),
                );
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                ticket_customized_field_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::ticket_customized_field::GET);
                let op = op.path_param(
                    "ticket_customized_field_id",
                    ticket_customized_field_id.into(),
                );
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::ticket_customized_field::LIST);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                ticket_customized_field_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::ticket_customized_field::PATCH);
                let op = op.path_param(
                    "ticket_customized_field_id",
                    ticket_customized_field_id.into(),
                );
                op
            }
        }

        pub mod ticket_message {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                ticket_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::ticket_message::CREATE);
                let op = op.path_param("ticket_id", ticket_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                ticket_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::helpdesk::v1::ticket_message::LIST);
                let op = op.path_param("ticket_id", ticket_id.into());
                op
            }
        }
    }
}

pub mod hire {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod advertisement {
            use super::*;
            pub fn publish<'a>(
                client: &'a Client,
                advertisement_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::advertisement::PUBLISH);
                let op = op.path_param("advertisement_id", advertisement_id.into());
                op
            }
        }

        pub mod agency {
            use super::*;
            pub fn batch_query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::agency::BATCH_QUERY);
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                agency_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::agency::GET);
                let op = op.path_param("agency_id", agency_id.into());
                op
            }

            pub fn get_agency_account<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::agency::GET_AGENCY_ACCOUNT);
                op
            }

            pub fn operate_agency_account<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::agency::OPERATE_AGENCY_ACCOUNT);
                op
            }

            pub fn protect<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::agency::PROTECT);
                op
            }

            pub fn protect_search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::agency::PROTECT_SEARCH);
                op
            }

            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::agency::QUERY);
                op
            }
        }

        pub mod application {
            use super::*;
            pub fn cancel_onboard<'a>(
                client: &'a Client,
                application_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::application::CANCEL_ONBOARD);
                let op = op.path_param("application_id", application_id.into());
                op
            }

            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::application::CREATE);
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                application_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::application::GET);
                let op = op.path_param("application_id", application_id.into());
                op
            }

            pub fn get_detail<'a>(
                client: &'a Client,
                application_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::application::GET_DETAIL);
                let op = op.path_param("application_id", application_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::application::LIST);
                op
            }

            pub fn offer<'a>(
                client: &'a Client,
                application_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::application::OFFER);
                let op = op.path_param("application_id", application_id.into());
                op
            }

            pub fn recover<'a>(
                client: &'a Client,
                application_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::application::RECOVER);
                let op = op.path_param("application_id", application_id.into());
                op
            }

            pub fn terminate<'a>(
                client: &'a Client,
                application_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::application::TERMINATE);
                let op = op.path_param("application_id", application_id.into());
                op
            }

            pub fn transfer_onboard<'a>(
                client: &'a Client,
                application_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::application::TRANSFER_ONBOARD);
                let op = op.path_param("application_id", application_id.into());
                op
            }

            pub fn transfer_stage<'a>(
                client: &'a Client,
                application_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::application::TRANSFER_STAGE);
                let op = op.path_param("application_id", application_id.into());
                op
            }
        }

        pub mod application_interview {
            use super::*;
            pub fn list<'a>(
                client: &'a Client,
                application_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::application_interview::LIST);
                let op = op.path_param("application_id", application_id.into());
                op
            }
        }

        pub mod attachment {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::attachment::CREATE);
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                attachment_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::attachment::GET);
                let op = op.path_param("attachment_id", attachment_id.into());
                op
            }

            pub fn preview<'a>(
                client: &'a Client,
                attachment_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::attachment::PREVIEW);
                let op = op.path_param("attachment_id", attachment_id.into());
                op
            }
        }

        pub mod background_check_order {
            use super::*;
            pub fn batch_query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::background_check_order::BATCH_QUERY);
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::background_check_order::LIST);
                op
            }
        }

        pub mod diversity_inclusion {
            use super::*;
            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::diversity_inclusion::SEARCH);
                op
            }
        }

        pub mod eco_account_custom_field {
            use super::*;
            pub fn batch_delete<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::eco_account_custom_field::BATCH_DELETE);
                op
            }

            pub fn batch_update<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::eco_account_custom_field::BATCH_UPDATE);
                op
            }

            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::eco_account_custom_field::CREATE);
                op
            }
        }

        pub mod eco_background_check {
            use super::*;
            pub fn cancel<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::eco_background_check::CANCEL);
                op
            }

            pub fn update_progress<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::eco_background_check::UPDATE_PROGRESS);
                op
            }

            pub fn update_result<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::eco_background_check::UPDATE_RESULT);
                op
            }
        }

        pub mod eco_background_check_custom_field {
            use super::*;
            pub fn batch_delete<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client
                    .operation(ops::hire::v1::eco_background_check_custom_field::BATCH_DELETE);
                op
            }

            pub fn batch_update<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client
                    .operation(ops::hire::v1::eco_background_check_custom_field::BATCH_UPDATE);
                op
            }

            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::eco_background_check_custom_field::CREATE);
                op
            }
        }

        pub mod eco_background_check_package {
            use super::*;
            pub fn batch_delete<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op =
                    client.operation(ops::hire::v1::eco_background_check_package::BATCH_DELETE);
                op
            }

            pub fn batch_update<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op =
                    client.operation(ops::hire::v1::eco_background_check_package::BATCH_UPDATE);
                op
            }

            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::eco_background_check_package::CREATE);
                op
            }
        }

        pub mod eco_exam {
            use super::*;
            pub fn login_info<'a>(
                client: &'a Client,
                exam_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::eco_exam::LOGIN_INFO);
                let op = op.path_param("exam_id", exam_id.into());
                op
            }

            pub fn update_result<'a>(
                client: &'a Client,
                exam_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::eco_exam::UPDATE_RESULT);
                let op = op.path_param("exam_id", exam_id.into());
                op
            }
        }

        pub mod eco_exam_paper {
            use super::*;
            pub fn batch_delete<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::eco_exam_paper::BATCH_DELETE);
                op
            }

            pub fn batch_update<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::eco_exam_paper::BATCH_UPDATE);
                op
            }

            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::eco_exam_paper::CREATE);
                op
            }
        }

        pub mod ehr_import_task {
            use super::*;
            pub fn patch<'a>(
                client: &'a Client,
                ehr_import_task_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::ehr_import_task::PATCH);
                let op = op.path_param("ehr_import_task_id", ehr_import_task_id.into());
                op
            }
        }

        pub mod employee {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                employee_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::employee::GET);
                let op = op.path_param("employee_id", employee_id.into());
                op
            }

            pub fn get_by_application<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::employee::GET_BY_APPLICATION);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                employee_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::employee::PATCH);
                let op = op.path_param("employee_id", employee_id.into());
                op
            }
        }

        pub mod evaluation {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::evaluation::LIST);
                op
            }
        }

        pub mod evaluation_task {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::evaluation_task::LIST);
                op
            }
        }

        pub mod exam {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::exam::CREATE);
                op
            }
        }

        pub mod exam_marking_task {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::exam_marking_task::LIST);
                op
            }
        }

        pub mod external_application {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::external_application::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                external_application_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::external_application::DELETE);
                let op = op.path_param("external_application_id", external_application_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::external_application::LIST);
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                external_application_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::external_application::UPDATE);
                let op = op.path_param("external_application_id", external_application_id.into());
                op
            }
        }

        pub mod external_background_check {
            use super::*;
            pub fn batch_query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::external_background_check::BATCH_QUERY);
                op
            }

            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::external_background_check::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                external_background_check_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::external_background_check::DELETE);
                let op = op.path_param(
                    "external_background_check_id",
                    external_background_check_id.into(),
                );
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                external_background_check_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::external_background_check::UPDATE);
                let op = op.path_param(
                    "external_background_check_id",
                    external_background_check_id.into(),
                );
                op
            }
        }

        pub mod external_interview {
            use super::*;
            pub fn batch_query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::external_interview::BATCH_QUERY);
                op
            }

            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::external_interview::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                external_interview_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::external_interview::DELETE);
                let op = op.path_param("external_interview_id", external_interview_id.into());
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                external_interview_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::external_interview::UPDATE);
                let op = op.path_param("external_interview_id", external_interview_id.into());
                op
            }
        }

        pub mod external_interview_assessment {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::external_interview_assessment::CREATE);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                external_interview_assessment_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::external_interview_assessment::PATCH);
                let op = op.path_param(
                    "external_interview_assessment_id",
                    external_interview_assessment_id.into(),
                );
                op
            }
        }

        pub mod external_offer {
            use super::*;
            pub fn batch_query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::external_offer::BATCH_QUERY);
                op
            }

            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::external_offer::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                external_offer_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::external_offer::DELETE);
                let op = op.path_param("external_offer_id", external_offer_id.into());
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                external_offer_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::external_offer::UPDATE);
                let op = op.path_param("external_offer_id", external_offer_id.into());
                op
            }
        }

        pub mod external_referral_reward {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::external_referral_reward::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                external_referral_reward_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::external_referral_reward::DELETE);
                let op = op.path_param(
                    "external_referral_reward_id",
                    external_referral_reward_id.into(),
                );
                op
            }
        }

        pub mod interview {
            use super::*;
            pub fn get_by_talent<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::interview::GET_BY_TALENT);
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::interview::LIST);
                op
            }
        }

        pub mod interview_feedback_form {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::interview_feedback_form::LIST);
                op
            }
        }

        pub mod interview_record {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                interview_record_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::interview_record::GET);
                let op = op.path_param("interview_record_id", interview_record_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::interview_record::LIST);
                op
            }
        }

        pub mod interview_record_attachment {
            use super::*;
            pub fn get<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::interview_record_attachment::GET);
                op
            }
        }

        pub mod interview_registration_schema {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::interview_registration_schema::LIST);
                op
            }
        }

        pub mod interview_round_type {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::interview_round_type::LIST);
                op
            }
        }

        pub mod interview_task {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::interview_task::LIST);
                op
            }
        }

        pub mod interviewer {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::interviewer::LIST);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                interviewer_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::interviewer::PATCH);
                let op = op.path_param("interviewer_id", interviewer_id.into());
                op
            }
        }

        pub mod job {
            use super::*;
            pub fn close<'a>(
                client: &'a Client,
                job_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::job::CLOSE);
                let op = op.path_param("job_id", job_id.into());
                op
            }

            pub fn combined_create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::job::COMBINED_CREATE);
                op
            }

            pub fn combined_update<'a>(
                client: &'a Client,
                job_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::job::COMBINED_UPDATE);
                let op = op.path_param("job_id", job_id.into());
                op
            }

            pub fn config<'a>(
                client: &'a Client,
                job_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::job::CONFIG);
                let op = op.path_param("job_id", job_id.into());
                op
            }

            pub fn get<'a>(client: &'a Client, job_id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::job::GET);
                let op = op.path_param("job_id", job_id.into());
                op
            }

            pub fn get_detail<'a>(
                client: &'a Client,
                job_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::job::GET_DETAIL);
                let op = op.path_param("job_id", job_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::job::LIST);
                op
            }

            pub fn open<'a>(client: &'a Client, job_id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::job::OPEN);
                let op = op.path_param("job_id", job_id.into());
                op
            }

            pub fn recruiter<'a>(
                client: &'a Client,
                job_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::job::RECRUITER);
                let op = op.path_param("job_id", job_id.into());
                op
            }

            pub fn update_config<'a>(
                client: &'a Client,
                job_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::job::UPDATE_CONFIG);
                let op = op.path_param("job_id", job_id.into());
                op
            }
        }

        pub mod job_function {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::job_function::LIST);
                op
            }
        }

        pub mod job_manager {
            use super::*;
            pub fn batch_update<'a>(
                client: &'a Client,
                job_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::job_manager::BATCH_UPDATE);
                let op = op.path_param("job_id", job_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                job_id: impl Into<String>,
                manager_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::job_manager::GET);
                let op = op
                    .path_param("job_id", job_id.into())
                    .path_param("manager_id", manager_id.into());
                op
            }
        }

        pub mod job_process {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::job_process::LIST);
                op
            }
        }

        pub mod job_publish_record {
            use super::*;
            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::job_publish_record::SEARCH);
                op
            }
        }

        pub mod job_requirement {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::job_requirement::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                job_requirement_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::job_requirement::DELETE);
                let op = op.path_param("job_requirement_id", job_requirement_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::job_requirement::LIST);
                op
            }

            pub fn list_by_id<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::job_requirement::LIST_BY_ID);
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                job_requirement_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::job_requirement::UPDATE);
                let op = op.path_param("job_requirement_id", job_requirement_id.into());
                op
            }
        }

        pub mod job_requirement_schema {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::job_requirement_schema::LIST);
                op
            }
        }

        pub mod job_schema {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::job_schema::LIST);
                op
            }
        }

        pub mod job_type {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::job_type::LIST);
                op
            }
        }

        pub mod location {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::location::LIST);
                op
            }

            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::location::QUERY);
                op
            }
        }

        pub mod minutes {
            use super::*;
            pub fn get<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::minutes::GET);
                op
            }
        }

        pub mod note {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::note::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                note_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::note::DELETE);
                let op = op.path_param("note_id", note_id.into());
                op
            }

            pub fn get<'a>(client: &'a Client, note_id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::note::GET);
                let op = op.path_param("note_id", note_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::note::LIST);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                note_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::note::PATCH);
                let op = op.path_param("note_id", note_id.into());
                op
            }
        }

        pub mod offer {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::offer::CREATE);
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                offer_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::offer::GET);
                let op = op.path_param("offer_id", offer_id.into());
                op
            }

            pub fn intern_offer_status<'a>(
                client: &'a Client,
                offer_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::offer::INTERN_OFFER_STATUS);
                let op = op.path_param("offer_id", offer_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::offer::LIST);
                op
            }

            pub fn offer_status<'a>(
                client: &'a Client,
                offer_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::offer::OFFER_STATUS);
                let op = op.path_param("offer_id", offer_id.into());
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                offer_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::offer::UPDATE);
                let op = op.path_param("offer_id", offer_id.into());
                op
            }
        }

        pub mod offer_application_form {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                offer_application_form_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::offer_application_form::GET);
                let op = op.path_param(
                    "offer_application_form_id",
                    offer_application_form_id.into(),
                );
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::offer_application_form::LIST);
                op
            }
        }

        pub mod offer_approval_template {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::offer_approval_template::LIST);
                op
            }
        }

        pub mod offer_custom_field {
            use super::*;
            pub fn update<'a>(
                client: &'a Client,
                offer_custom_field_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::offer_custom_field::UPDATE);
                let op = op.path_param("offer_custom_field_id", offer_custom_field_id.into());
                op
            }
        }

        pub mod offer_schema {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                offer_schema_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::offer_schema::GET);
                let op = op.path_param("offer_schema_id", offer_schema_id.into());
                op
            }
        }

        pub mod portal_apply_schema {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::portal_apply_schema::LIST);
                op
            }
        }

        pub mod questionnaire {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::questionnaire::LIST);
                op
            }
        }

        pub mod referral {
            use super::*;
            pub fn get_by_application<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::referral::GET_BY_APPLICATION);
                op
            }

            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::referral::SEARCH);
                op
            }
        }

        pub mod referral_account {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::referral_account::CREATE);
                op
            }

            pub fn deactivate<'a>(
                client: &'a Client,
                referral_account_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::referral_account::DEACTIVATE);
                let op = op.path_param("referral_account_id", referral_account_id.into());
                op
            }

            pub fn enable<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::referral_account::ENABLE);
                op
            }

            pub fn get_account_assets<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::referral_account::GET_ACCOUNT_ASSETS);
                op
            }

            pub fn reconciliation<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::referral_account::RECONCILIATION);
                op
            }

            pub fn withdraw<'a>(
                client: &'a Client,
                referral_account_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::referral_account::WITHDRAW);
                let op = op.path_param("referral_account_id", referral_account_id.into());
                op
            }
        }

        pub mod referral_website_job_post {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                job_post_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::referral_website_job_post::GET);
                let op = op.path_param("job_post_id", job_post_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::referral_website_job_post::LIST);
                op
            }
        }

        pub mod registration_schema {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::registration_schema::LIST);
                op
            }
        }

        pub mod resume_source {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::resume_source::LIST);
                op
            }
        }

        pub mod role {
            use super::*;
            pub fn get<'a>(client: &'a Client, role_id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::role::GET);
                let op = op.path_param("role_id", role_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::role::LIST);
                op
            }
        }

        pub mod subject {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::subject::LIST);
                op
            }
        }

        pub mod talent {
            use super::*;
            pub fn add_to_folder<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::talent::ADD_TO_FOLDER);
                op
            }

            pub fn batch_get_id<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::talent::BATCH_GET_ID);
                op
            }

            pub fn combined_create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::talent::COMBINED_CREATE);
                op
            }

            pub fn combined_update<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::talent::COMBINED_UPDATE);
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                talent_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::talent::GET);
                let op = op.path_param("talent_id", talent_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::talent::LIST);
                op
            }

            pub fn onboard_status<'a>(
                client: &'a Client,
                talent_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::talent::ONBOARD_STATUS);
                let op = op.path_param("talent_id", talent_id.into());
                op
            }

            pub fn remove_to_folder<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::talent::REMOVE_TO_FOLDER);
                op
            }

            pub fn tag<'a>(
                client: &'a Client,
                talent_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::talent::TAG);
                let op = op.path_param("talent_id", talent_id.into());
                op
            }
        }

        pub mod talent_blocklist {
            use super::*;
            pub fn change_talent_block<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::talent_blocklist::CHANGE_TALENT_BLOCK);
                op
            }
        }

        pub mod talent_external_info {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                talent_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::talent_external_info::CREATE);
                let op = op.path_param("talent_id", talent_id.into());
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                talent_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::talent_external_info::UPDATE);
                let op = op.path_param("talent_id", talent_id.into());
                op
            }
        }

        pub mod talent_folder {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::talent_folder::LIST);
                op
            }
        }

        pub mod talent_object {
            use super::*;
            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::talent_object::QUERY);
                op
            }
        }

        pub mod talent_operation_log {
            use super::*;
            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::talent_operation_log::SEARCH);
                op
            }
        }

        pub mod talent_pool {
            use super::*;
            pub fn batch_change_talent_pool<'a>(
                client: &'a Client,
                talent_pool_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::talent_pool::BATCH_CHANGE_TALENT_POOL);
                let op = op.path_param("talent_pool_id", talent_pool_id.into());
                op
            }

            pub fn move_talent<'a>(
                client: &'a Client,
                talent_pool_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::talent_pool::MOVE_TALENT);
                let op = op.path_param("talent_pool_id", talent_pool_id.into());
                op
            }

            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::talent_pool::SEARCH);
                op
            }
        }

        pub mod talent_tag {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::talent_tag::LIST);
                op
            }
        }

        pub mod termination_reason {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::termination_reason::LIST);
                op
            }
        }

        pub mod test {
            use super::*;
            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::test::SEARCH);
                op
            }
        }

        pub mod todo {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::todo::LIST);
                op
            }
        }

        pub mod tripartite_agreement {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::tripartite_agreement::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                tripartite_agreement_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::tripartite_agreement::DELETE);
                let op = op.path_param("tripartite_agreement_id", tripartite_agreement_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::tripartite_agreement::LIST);
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                tripartite_agreement_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::tripartite_agreement::UPDATE);
                let op = op.path_param("tripartite_agreement_id", tripartite_agreement_id.into());
                op
            }
        }

        pub mod user_role {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::user_role::LIST);
                op
            }
        }

        pub mod website {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::website::LIST);
                op
            }
        }

        pub mod website_channel {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                website_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::website_channel::CREATE);
                let op = op.path_param("website_id", website_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                website_id: impl Into<String>,
                channel_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::website_channel::DELETE);
                let op = op
                    .path_param("website_id", website_id.into())
                    .path_param("channel_id", channel_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                website_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::website_channel::LIST);
                let op = op.path_param("website_id", website_id.into());
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                website_id: impl Into<String>,
                channel_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::website_channel::UPDATE);
                let op = op
                    .path_param("website_id", website_id.into())
                    .path_param("channel_id", channel_id.into());
                op
            }
        }

        pub mod website_delivery {
            use super::*;
            pub fn create_by_attachment<'a>(
                client: &'a Client,
                website_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::website_delivery::CREATE_BY_ATTACHMENT);
                let op = op.path_param("website_id", website_id.into());
                op
            }

            pub fn create_by_resume<'a>(
                client: &'a Client,
                website_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::website_delivery::CREATE_BY_RESUME);
                let op = op.path_param("website_id", website_id.into());
                op
            }
        }

        pub mod website_delivery_task {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                website_id: impl Into<String>,
                delivery_task_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::website_delivery_task::GET);
                let op = op
                    .path_param("website_id", website_id.into())
                    .path_param("delivery_task_id", delivery_task_id.into());
                op
            }
        }

        pub mod website_job_post {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                website_id: impl Into<String>,
                job_post_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::website_job_post::GET);
                let op = op
                    .path_param("website_id", website_id.into())
                    .path_param("job_post_id", job_post_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                website_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::website_job_post::LIST);
                let op = op.path_param("website_id", website_id.into());
                op
            }

            pub fn search<'a>(
                client: &'a Client,
                website_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::website_job_post::SEARCH);
                let op = op.path_param("website_id", website_id.into());
                op
            }
        }

        pub mod website_site_user {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                website_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v1::website_site_user::CREATE);
                let op = op.path_param("website_id", website_id.into());
                op
            }
        }
    }

    pub mod v2 {
        use super::*;
        pub mod interview_record {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                interview_record_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v2::interview_record::GET);
                let op = op.path_param("interview_record_id", interview_record_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v2::interview_record::LIST);
                op
            }
        }

        pub mod talent {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                talent_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::hire::v2::talent::GET);
                let op = op.path_param("talent_id", talent_id.into());
                op
            }
        }
    }
}

pub mod human_authentication {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod identity {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::human_authentication::v1::identity::CREATE);
                op
            }
        }
    }
}

pub mod im {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod batch_message {
            use super::*;
            pub fn delete<'a>(
                client: &'a Client,
                batch_message_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::batch_message::DELETE);
                let op = op.path_param("batch_message_id", batch_message_id.into());
                op
            }

            pub fn get_progress<'a>(
                client: &'a Client,
                batch_message_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::batch_message::GET_PROGRESS);
                let op = op.path_param("batch_message_id", batch_message_id.into());
                op
            }

            pub fn read_user<'a>(
                client: &'a Client,
                batch_message_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::batch_message::READ_USER);
                let op = op.path_param("batch_message_id", batch_message_id.into());
                op
            }
        }

        pub mod chat {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::chat::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                chat_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::chat::DELETE);
                let op = op.path_param("chat_id", chat_id.into());
                op
            }

            pub fn get<'a>(client: &'a Client, chat_id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::chat::GET);
                let op = op.path_param("chat_id", chat_id.into());
                op
            }

            pub fn link<'a>(
                client: &'a Client,
                chat_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::chat::LINK);
                let op = op.path_param("chat_id", chat_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::chat::LIST);
                op
            }

            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::chat::SEARCH);
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                chat_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::chat::UPDATE);
                let op = op.path_param("chat_id", chat_id.into());
                op
            }
        }

        pub mod chat_announcement {
            use super::*;
            pub fn get<'a>(client: &'a Client, chat_id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::chat_announcement::GET);
                let op = op.path_param("chat_id", chat_id.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                chat_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::chat_announcement::PATCH);
                let op = op.path_param("chat_id", chat_id.into());
                op
            }
        }

        pub mod chat_managers {
            use super::*;
            pub fn add_managers<'a>(
                client: &'a Client,
                chat_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::chat_managers::ADD_MANAGERS);
                let op = op.path_param("chat_id", chat_id.into());
                op
            }

            pub fn delete_managers<'a>(
                client: &'a Client,
                chat_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::chat_managers::DELETE_MANAGERS);
                let op = op.path_param("chat_id", chat_id.into());
                op
            }
        }

        pub mod chat_members {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                chat_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::chat_members::CREATE);
                let op = op.path_param("chat_id", chat_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                chat_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::chat_members::DELETE);
                let op = op.path_param("chat_id", chat_id.into());
                op
            }

            pub fn get<'a>(client: &'a Client, chat_id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::chat_members::GET);
                let op = op.path_param("chat_id", chat_id.into());
                op
            }

            pub fn is_in_chat<'a>(
                client: &'a Client,
                chat_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::chat_members::IS_IN_CHAT);
                let op = op.path_param("chat_id", chat_id.into());
                op
            }

            pub fn me_join<'a>(
                client: &'a Client,
                chat_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::chat_members::ME_JOIN);
                let op = op.path_param("chat_id", chat_id.into());
                op
            }
        }

        pub mod chat_menu_item {
            use super::*;
            pub fn patch<'a>(
                client: &'a Client,
                chat_id: impl Into<String>,
                menu_item_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::chat_menu_item::PATCH);
                let op = op
                    .path_param("chat_id", chat_id.into())
                    .path_param("menu_item_id", menu_item_id.into());
                op
            }
        }

        pub mod chat_menu_tree {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                chat_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::chat_menu_tree::CREATE);
                let op = op.path_param("chat_id", chat_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                chat_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::chat_menu_tree::DELETE);
                let op = op.path_param("chat_id", chat_id.into());
                op
            }

            pub fn get<'a>(client: &'a Client, chat_id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::chat_menu_tree::GET);
                let op = op.path_param("chat_id", chat_id.into());
                op
            }

            pub fn sort<'a>(
                client: &'a Client,
                chat_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::chat_menu_tree::SORT);
                let op = op.path_param("chat_id", chat_id.into());
                op
            }
        }

        pub mod chat_moderation {
            use super::*;
            pub fn get<'a>(client: &'a Client, chat_id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::chat_moderation::GET);
                let op = op.path_param("chat_id", chat_id.into());
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                chat_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::chat_moderation::UPDATE);
                let op = op.path_param("chat_id", chat_id.into());
                op
            }
        }

        pub mod chat_tab {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                chat_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::chat_tab::CREATE);
                let op = op.path_param("chat_id", chat_id.into());
                op
            }

            pub fn delete_tabs<'a>(
                client: &'a Client,
                chat_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::chat_tab::DELETE_TABS);
                let op = op.path_param("chat_id", chat_id.into());
                op
            }

            pub fn list_tabs<'a>(
                client: &'a Client,
                chat_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::chat_tab::LIST_TABS);
                let op = op.path_param("chat_id", chat_id.into());
                op
            }

            pub fn sort_tabs<'a>(
                client: &'a Client,
                chat_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::chat_tab::SORT_TABS);
                let op = op.path_param("chat_id", chat_id.into());
                op
            }

            pub fn update_tabs<'a>(
                client: &'a Client,
                chat_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::chat_tab::UPDATE_TABS);
                let op = op.path_param("chat_id", chat_id.into());
                op
            }
        }

        pub mod chat_top_notice {
            use super::*;
            pub fn delete_top_notice<'a>(
                client: &'a Client,
                chat_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::chat_top_notice::DELETE_TOP_NOTICE);
                let op = op.path_param("chat_id", chat_id.into());
                op
            }

            pub fn put_top_notice<'a>(
                client: &'a Client,
                chat_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::chat_top_notice::PUT_TOP_NOTICE);
                let op = op.path_param("chat_id", chat_id.into());
                op
            }
        }

        pub mod file {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::file::CREATE);
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                file_key: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::file::GET);
                let op = op.path_param("file_key", file_key.into());
                op
            }
        }

        pub mod image {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::image::CREATE);
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                image_key: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::image::GET);
                let op = op.path_param("image_key", image_key.into());
                op
            }
        }

        pub mod message {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::message::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                message_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::message::DELETE);
                let op = op.path_param("message_id", message_id.into());
                op
            }

            pub fn forward<'a>(
                client: &'a Client,
                message_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::message::FORWARD);
                let op = op.path_param("message_id", message_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                message_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::message::GET);
                let op = op.path_param("message_id", message_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::message::LIST);
                op
            }

            pub fn merge_forward<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::message::MERGE_FORWARD);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                message_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::message::PATCH);
                let op = op.path_param("message_id", message_id.into());
                op
            }

            pub fn push_follow_up<'a>(
                client: &'a Client,
                message_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::message::PUSH_FOLLOW_UP);
                let op = op.path_param("message_id", message_id.into());
                op
            }

            pub fn read_users<'a>(
                client: &'a Client,
                message_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::message::READ_USERS);
                let op = op.path_param("message_id", message_id.into());
                op
            }

            pub fn reply<'a>(
                client: &'a Client,
                message_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::message::REPLY);
                let op = op.path_param("message_id", message_id.into());
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                message_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::message::UPDATE);
                let op = op.path_param("message_id", message_id.into());
                op
            }

            pub fn urgent_app<'a>(
                client: &'a Client,
                message_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::message::URGENT_APP);
                let op = op.path_param("message_id", message_id.into());
                op
            }

            pub fn urgent_phone<'a>(
                client: &'a Client,
                message_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::message::URGENT_PHONE);
                let op = op.path_param("message_id", message_id.into());
                op
            }

            pub fn urgent_sms<'a>(
                client: &'a Client,
                message_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::message::URGENT_SMS);
                let op = op.path_param("message_id", message_id.into());
                op
            }
        }

        pub mod message_reaction {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                message_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::message_reaction::CREATE);
                let op = op.path_param("message_id", message_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                message_id: impl Into<String>,
                reaction_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::message_reaction::DELETE);
                let op = op
                    .path_param("message_id", message_id.into())
                    .path_param("reaction_id", reaction_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                message_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::message_reaction::LIST);
                let op = op.path_param("message_id", message_id.into());
                op
            }
        }

        pub mod message_resource {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                message_id: impl Into<String>,
                file_key: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::message_resource::GET);
                let op = op
                    .path_param("message_id", message_id.into())
                    .path_param("file_key", file_key.into());
                op
            }
        }

        pub mod pin {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::pin::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                message_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::pin::DELETE);
                let op = op.path_param("message_id", message_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::pin::LIST);
                op
            }
        }

        pub mod thread {
            use super::*;
            pub fn forward<'a>(
                client: &'a Client,
                thread_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v1::thread::FORWARD);
                let op = op.path_param("thread_id", thread_id.into());
                op
            }
        }
    }

    pub mod v2 {
        use super::*;
        pub mod app_feed_card {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v2::app_feed_card::CREATE);
                op
            }
        }

        pub mod app_feed_card_batch {
            use super::*;
            pub fn delete<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v2::app_feed_card_batch::DELETE);
                op
            }

            pub fn update<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v2::app_feed_card_batch::UPDATE);
                op
            }
        }

        pub mod biz_entity_tag_relation {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v2::biz_entity_tag_relation::CREATE);
                op
            }

            pub fn get<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v2::biz_entity_tag_relation::GET);
                op
            }

            pub fn update<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v2::biz_entity_tag_relation::UPDATE);
                op
            }
        }

        pub mod chat_button {
            use super::*;
            pub fn update<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v2::chat_button::UPDATE);
                op
            }
        }

        pub mod feed_card {
            use super::*;
            pub fn bot_time_sentive<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v2::feed_card::BOT_TIME_SENTIVE);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                feed_card_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v2::feed_card::PATCH);
                let op = op.path_param("feed_card_id", feed_card_id.into());
                op
            }
        }

        pub mod tag {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v2::tag::CREATE);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                tag_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v2::tag::PATCH);
                let op = op.path_param("tag_id", tag_id.into());
                op
            }
        }

        pub mod url_preview {
            use super::*;
            pub fn batch_update<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::im::v2::url_preview::BATCH_UPDATE);
                op
            }
        }
    }
}

pub mod lingo {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod classification {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::lingo::v1::classification::LIST);
                op
            }
        }

        pub mod draft {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::lingo::v1::draft::CREATE);
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                draft_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::lingo::v1::draft::UPDATE);
                let op = op.path_param("draft_id", draft_id.into());
                op
            }
        }

        pub mod entity {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::lingo::v1::entity::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                entity_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::lingo::v1::entity::DELETE);
                let op = op.path_param("entity_id", entity_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                entity_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::lingo::v1::entity::GET);
                let op = op.path_param("entity_id", entity_id.into());
                op
            }

            pub fn highlight<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::lingo::v1::entity::HIGHLIGHT);
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::lingo::v1::entity::LIST);
                op
            }

            pub fn match_<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::lingo::v1::entity::MATCH);
                op
            }

            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::lingo::v1::entity::SEARCH);
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                entity_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::lingo::v1::entity::UPDATE);
                let op = op.path_param("entity_id", entity_id.into());
                op
            }
        }

        pub mod file {
            use super::*;
            pub fn download<'a>(
                client: &'a Client,
                file_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::lingo::v1::file::DOWNLOAD);
                let op = op.path_param("file_token", file_token.into());
                op
            }

            pub fn upload<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::lingo::v1::file::UPLOAD);
                op
            }
        }

        pub mod repo {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::lingo::v1::repo::LIST);
                op
            }
        }
    }
}

pub mod mail {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod mailgroup {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::mailgroup::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                mailgroup_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::mailgroup::DELETE);
                let op = op.path_param("mailgroup_id", mailgroup_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                mailgroup_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::mailgroup::GET);
                let op = op.path_param("mailgroup_id", mailgroup_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::mailgroup::LIST);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                mailgroup_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::mailgroup::PATCH);
                let op = op.path_param("mailgroup_id", mailgroup_id.into());
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                mailgroup_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::mailgroup::UPDATE);
                let op = op.path_param("mailgroup_id", mailgroup_id.into());
                op
            }
        }

        pub mod mailgroup_alias {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                mailgroup_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::mailgroup_alias::CREATE);
                let op = op.path_param("mailgroup_id", mailgroup_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                mailgroup_id: impl Into<String>,
                alias_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::mailgroup_alias::DELETE);
                let op = op
                    .path_param("mailgroup_id", mailgroup_id.into())
                    .path_param("alias_id", alias_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                mailgroup_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::mailgroup_alias::LIST);
                let op = op.path_param("mailgroup_id", mailgroup_id.into());
                op
            }
        }

        pub mod mailgroup_manager {
            use super::*;
            pub fn batch_create<'a>(
                client: &'a Client,
                mailgroup_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::mailgroup_manager::BATCH_CREATE);
                let op = op.path_param("mailgroup_id", mailgroup_id.into());
                op
            }

            pub fn batch_delete<'a>(
                client: &'a Client,
                mailgroup_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::mailgroup_manager::BATCH_DELETE);
                let op = op.path_param("mailgroup_id", mailgroup_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                mailgroup_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::mailgroup_manager::LIST);
                let op = op.path_param("mailgroup_id", mailgroup_id.into());
                op
            }
        }

        pub mod mailgroup_member {
            use super::*;
            pub fn batch_create<'a>(
                client: &'a Client,
                mailgroup_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::mailgroup_member::BATCH_CREATE);
                let op = op.path_param("mailgroup_id", mailgroup_id.into());
                op
            }

            pub fn batch_delete<'a>(
                client: &'a Client,
                mailgroup_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::mailgroup_member::BATCH_DELETE);
                let op = op.path_param("mailgroup_id", mailgroup_id.into());
                op
            }

            pub fn create<'a>(
                client: &'a Client,
                mailgroup_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::mailgroup_member::CREATE);
                let op = op.path_param("mailgroup_id", mailgroup_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                mailgroup_id: impl Into<String>,
                member_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::mailgroup_member::DELETE);
                let op = op
                    .path_param("mailgroup_id", mailgroup_id.into())
                    .path_param("member_id", member_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                mailgroup_id: impl Into<String>,
                member_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::mailgroup_member::GET);
                let op = op
                    .path_param("mailgroup_id", mailgroup_id.into())
                    .path_param("member_id", member_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                mailgroup_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::mailgroup_member::LIST);
                let op = op.path_param("mailgroup_id", mailgroup_id.into());
                op
            }
        }

        pub mod mailgroup_permission_member {
            use super::*;
            pub fn batch_create<'a>(
                client: &'a Client,
                mailgroup_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::mailgroup_permission_member::BATCH_CREATE);
                let op = op.path_param("mailgroup_id", mailgroup_id.into());
                op
            }

            pub fn batch_delete<'a>(
                client: &'a Client,
                mailgroup_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::mailgroup_permission_member::BATCH_DELETE);
                let op = op.path_param("mailgroup_id", mailgroup_id.into());
                op
            }

            pub fn create<'a>(
                client: &'a Client,
                mailgroup_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::mailgroup_permission_member::CREATE);
                let op = op.path_param("mailgroup_id", mailgroup_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                mailgroup_id: impl Into<String>,
                permission_member_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::mailgroup_permission_member::DELETE);
                let op = op
                    .path_param("mailgroup_id", mailgroup_id.into())
                    .path_param("permission_member_id", permission_member_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                mailgroup_id: impl Into<String>,
                permission_member_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::mailgroup_permission_member::GET);
                let op = op
                    .path_param("mailgroup_id", mailgroup_id.into())
                    .path_param("permission_member_id", permission_member_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                mailgroup_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::mailgroup_permission_member::LIST);
                let op = op.path_param("mailgroup_id", mailgroup_id.into());
                op
            }
        }

        pub mod public_mailbox {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::public_mailbox::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                public_mailbox_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::public_mailbox::DELETE);
                let op = op.path_param("public_mailbox_id", public_mailbox_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                public_mailbox_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::public_mailbox::GET);
                let op = op.path_param("public_mailbox_id", public_mailbox_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::public_mailbox::LIST);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                public_mailbox_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::public_mailbox::PATCH);
                let op = op.path_param("public_mailbox_id", public_mailbox_id.into());
                op
            }

            pub fn remove_to_recycle_bin<'a>(
                client: &'a Client,
                public_mailbox_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::public_mailbox::REMOVE_TO_RECYCLE_BIN);
                let op = op.path_param("public_mailbox_id", public_mailbox_id.into());
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                public_mailbox_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::public_mailbox::UPDATE);
                let op = op.path_param("public_mailbox_id", public_mailbox_id.into());
                op
            }
        }

        pub mod public_mailbox_alias {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                public_mailbox_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::public_mailbox_alias::CREATE);
                let op = op.path_param("public_mailbox_id", public_mailbox_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                public_mailbox_id: impl Into<String>,
                alias_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::public_mailbox_alias::DELETE);
                let op = op
                    .path_param("public_mailbox_id", public_mailbox_id.into())
                    .path_param("alias_id", alias_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                public_mailbox_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::public_mailbox_alias::LIST);
                let op = op.path_param("public_mailbox_id", public_mailbox_id.into());
                op
            }
        }

        pub mod public_mailbox_member {
            use super::*;
            pub fn batch_create<'a>(
                client: &'a Client,
                public_mailbox_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::public_mailbox_member::BATCH_CREATE);
                let op = op.path_param("public_mailbox_id", public_mailbox_id.into());
                op
            }

            pub fn batch_delete<'a>(
                client: &'a Client,
                public_mailbox_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::public_mailbox_member::BATCH_DELETE);
                let op = op.path_param("public_mailbox_id", public_mailbox_id.into());
                op
            }

            pub fn clear<'a>(
                client: &'a Client,
                public_mailbox_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::public_mailbox_member::CLEAR);
                let op = op.path_param("public_mailbox_id", public_mailbox_id.into());
                op
            }

            pub fn create<'a>(
                client: &'a Client,
                public_mailbox_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::public_mailbox_member::CREATE);
                let op = op.path_param("public_mailbox_id", public_mailbox_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                public_mailbox_id: impl Into<String>,
                member_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::public_mailbox_member::DELETE);
                let op = op
                    .path_param("public_mailbox_id", public_mailbox_id.into())
                    .path_param("member_id", member_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                public_mailbox_id: impl Into<String>,
                member_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::public_mailbox_member::GET);
                let op = op
                    .path_param("public_mailbox_id", public_mailbox_id.into())
                    .path_param("member_id", member_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                public_mailbox_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::public_mailbox_member::LIST);
                let op = op.path_param("public_mailbox_id", public_mailbox_id.into());
                op
            }
        }

        pub mod user {
            use super::*;
            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::user::QUERY);
                op
            }
        }

        pub mod user_mailbox {
            use super::*;
            pub fn delete<'a>(
                client: &'a Client,
                user_mailbox_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::user_mailbox::DELETE);
                let op = op.path_param("user_mailbox_id", user_mailbox_id.into());
                op
            }
        }

        pub mod user_mailbox_alias {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                user_mailbox_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::user_mailbox_alias::CREATE);
                let op = op.path_param("user_mailbox_id", user_mailbox_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                user_mailbox_id: impl Into<String>,
                alias_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::user_mailbox_alias::DELETE);
                let op = op
                    .path_param("user_mailbox_id", user_mailbox_id.into())
                    .path_param("alias_id", alias_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                user_mailbox_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::user_mailbox_alias::LIST);
                let op = op.path_param("user_mailbox_id", user_mailbox_id.into());
                op
            }
        }

        pub mod user_mailbox_event {
            use super::*;
            pub fn subscribe<'a>(
                client: &'a Client,
                user_mailbox_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::user_mailbox_event::SUBSCRIBE);
                let op = op.path_param("user_mailbox_id", user_mailbox_id.into());
                op
            }

            pub fn subscription<'a>(
                client: &'a Client,
                user_mailbox_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::user_mailbox_event::SUBSCRIPTION);
                let op = op.path_param("user_mailbox_id", user_mailbox_id.into());
                op
            }

            pub fn unsubscribe<'a>(
                client: &'a Client,
                user_mailbox_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::user_mailbox_event::UNSUBSCRIBE);
                let op = op.path_param("user_mailbox_id", user_mailbox_id.into());
                op
            }
        }

        pub mod user_mailbox_folder {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                user_mailbox_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::user_mailbox_folder::CREATE);
                let op = op.path_param("user_mailbox_id", user_mailbox_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                user_mailbox_id: impl Into<String>,
                folder_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::user_mailbox_folder::DELETE);
                let op = op
                    .path_param("user_mailbox_id", user_mailbox_id.into())
                    .path_param("folder_id", folder_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                user_mailbox_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::user_mailbox_folder::LIST);
                let op = op.path_param("user_mailbox_id", user_mailbox_id.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                user_mailbox_id: impl Into<String>,
                folder_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::user_mailbox_folder::PATCH);
                let op = op
                    .path_param("user_mailbox_id", user_mailbox_id.into())
                    .path_param("folder_id", folder_id.into());
                op
            }
        }

        pub mod user_mailbox_mail_contact {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                user_mailbox_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::user_mailbox_mail_contact::CREATE);
                let op = op.path_param("user_mailbox_id", user_mailbox_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                user_mailbox_id: impl Into<String>,
                mail_contact_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::user_mailbox_mail_contact::DELETE);
                let op = op
                    .path_param("user_mailbox_id", user_mailbox_id.into())
                    .path_param("mail_contact_id", mail_contact_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                user_mailbox_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::user_mailbox_mail_contact::LIST);
                let op = op.path_param("user_mailbox_id", user_mailbox_id.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                user_mailbox_id: impl Into<String>,
                mail_contact_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::user_mailbox_mail_contact::PATCH);
                let op = op
                    .path_param("user_mailbox_id", user_mailbox_id.into())
                    .path_param("mail_contact_id", mail_contact_id.into());
                op
            }
        }

        pub mod user_mailbox_message {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                user_mailbox_id: impl Into<String>,
                message_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::user_mailbox_message::GET);
                let op = op
                    .path_param("user_mailbox_id", user_mailbox_id.into())
                    .path_param("message_id", message_id.into());
                op
            }

            pub fn get_by_card<'a>(
                client: &'a Client,
                user_mailbox_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::user_mailbox_message::GET_BY_CARD);
                let op = op.path_param("user_mailbox_id", user_mailbox_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                user_mailbox_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::user_mailbox_message::LIST);
                let op = op.path_param("user_mailbox_id", user_mailbox_id.into());
                op
            }

            pub fn send<'a>(
                client: &'a Client,
                user_mailbox_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::user_mailbox_message::SEND);
                let op = op.path_param("user_mailbox_id", user_mailbox_id.into());
                op
            }
        }

        pub mod user_mailbox_message_attachment {
            use super::*;
            pub fn download_url<'a>(
                client: &'a Client,
                user_mailbox_id: impl Into<String>,
                message_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op =
                    client.operation(ops::mail::v1::user_mailbox_message_attachment::DOWNLOAD_URL);
                let op = op
                    .path_param("user_mailbox_id", user_mailbox_id.into())
                    .path_param("message_id", message_id.into());
                op
            }
        }

        pub mod user_mailbox_rule {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                user_mailbox_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::user_mailbox_rule::CREATE);
                let op = op.path_param("user_mailbox_id", user_mailbox_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                user_mailbox_id: impl Into<String>,
                rule_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::user_mailbox_rule::DELETE);
                let op = op
                    .path_param("user_mailbox_id", user_mailbox_id.into())
                    .path_param("rule_id", rule_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                user_mailbox_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::user_mailbox_rule::LIST);
                let op = op.path_param("user_mailbox_id", user_mailbox_id.into());
                op
            }

            pub fn reorder<'a>(
                client: &'a Client,
                user_mailbox_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::user_mailbox_rule::REORDER);
                let op = op.path_param("user_mailbox_id", user_mailbox_id.into());
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                user_mailbox_id: impl Into<String>,
                rule_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::mail::v1::user_mailbox_rule::UPDATE);
                let op = op
                    .path_param("user_mailbox_id", user_mailbox_id.into())
                    .path_param("rule_id", rule_id.into());
                op
            }
        }
    }
}

pub mod mdm {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod user_auth_data_relation {
            use super::*;
            pub fn bind<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::mdm::v1::user_auth_data_relation::BIND);
                op
            }

            pub fn unbind<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::mdm::v1::user_auth_data_relation::UNBIND);
                op
            }
        }
    }

    pub mod v3 {
        use super::*;
        pub mod batch_country_region {
            use super::*;
            pub fn get<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::mdm::v3::batch_country_region::GET);
                op
            }
        }

        pub mod country_region {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::mdm::v3::country_region::LIST);
                op
            }
        }
    }
}

pub mod minutes {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod minute {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                minute_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::minutes::v1::minute::GET);
                let op = op.path_param("minute_token", minute_token.into());
                op
            }
        }

        pub mod minute_media {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                minute_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::minutes::v1::minute_media::GET);
                let op = op.path_param("minute_token", minute_token.into());
                op
            }
        }

        pub mod minute_statistics {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                minute_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::minutes::v1::minute_statistics::GET);
                let op = op.path_param("minute_token", minute_token.into());
                op
            }
        }

        pub mod minute_transcript {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                minute_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::minutes::v1::minute_transcript::GET);
                let op = op.path_param("minute_token", minute_token.into());
                op
            }
        }
    }
}

pub mod moments {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod post {
            use super::*;
            pub fn get<'a>(client: &'a Client, post_id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::moments::v1::post::GET);
                let op = op.path_param("post_id", post_id.into());
                op
            }
        }
    }
}

pub mod okr {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod image {
            use super::*;
            pub fn upload<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::okr::v1::image::UPLOAD);
                op
            }
        }

        pub mod okr {
            use super::*;
            pub fn batch_get<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::okr::v1::okr::BATCH_GET);
                op
            }
        }

        pub mod period {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::okr::v1::period::CREATE);
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::okr::v1::period::LIST);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                period_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::okr::v1::period::PATCH);
                let op = op.path_param("period_id", period_id.into());
                op
            }
        }

        pub mod period_rule {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::okr::v1::period_rule::LIST);
                op
            }
        }

        pub mod progress_record {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::okr::v1::progress_record::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                progress_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::okr::v1::progress_record::DELETE);
                let op = op.path_param("progress_id", progress_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                progress_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::okr::v1::progress_record::GET);
                let op = op.path_param("progress_id", progress_id.into());
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                progress_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::okr::v1::progress_record::UPDATE);
                let op = op.path_param("progress_id", progress_id.into());
                op
            }
        }

        pub mod review {
            use super::*;
            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::okr::v1::review::QUERY);
                op
            }
        }

        pub mod user_okr {
            use super::*;
            pub fn list<'a>(
                client: &'a Client,
                user_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::okr::v1::user_okr::LIST);
                let op = op.path_param("user_id", user_id.into());
                op
            }
        }
    }
}

pub mod optical_char_recognition {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod image {
            use super::*;
            pub fn basic_recognize<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op =
                    client.operation(ops::optical_char_recognition::v1::image::BASIC_RECOGNIZE);
                op
            }
        }
    }
}

pub mod passport {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod session {
            use super::*;
            pub fn logout<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::passport::v1::session::LOGOUT);
                op
            }

            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::passport::v1::session::QUERY);
                op
            }
        }
    }
}

pub mod payroll {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod acct_item {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::payroll::v1::acct_item::LIST);
                op
            }
        }

        pub mod cost_allocation_detail {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::payroll::v1::cost_allocation_detail::LIST);
                op
            }
        }

        pub mod cost_allocation_plan {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::payroll::v1::cost_allocation_plan::LIST);
                op
            }
        }

        pub mod cost_allocation_report {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::payroll::v1::cost_allocation_report::LIST);
                op
            }
        }

        pub mod datasource {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::payroll::v1::datasource::LIST);
                op
            }
        }

        pub mod datasource_record {
            use super::*;
            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::payroll::v1::datasource_record::QUERY);
                op
            }

            pub fn save<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::payroll::v1::datasource_record::SAVE);
                op
            }
        }

        pub mod paygroup {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::payroll::v1::paygroup::LIST);
                op
            }
        }

        pub mod payment_activity {
            use super::*;
            pub fn archive<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::payroll::v1::payment_activity::ARCHIVE);
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::payroll::v1::payment_activity::LIST);
                op
            }
        }

        pub mod payment_activity_detail {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::payroll::v1::payment_activity_detail::LIST);
                op
            }
        }

        pub mod payment_detail {
            use super::*;
            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::payroll::v1::payment_detail::QUERY);
                op
            }
        }
    }
}

pub mod performance {
    use super::*;
    pub mod v2 {
        use super::*;
        pub mod activity {
            use super::*;
            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::performance::v2::activity::QUERY);
                op
            }
        }

        pub mod additional_information {
            use super::*;
            pub fn import<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::performance::v2::additional_information::IMPORT);
                op
            }

            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::performance::v2::additional_information::QUERY);
                op
            }
        }

        pub mod additional_informations_batch {
            use super::*;
            pub fn delete<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op =
                    client.operation(ops::performance::v2::additional_informations_batch::DELETE);
                op
            }
        }

        pub mod indicator {
            use super::*;
            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::performance::v2::indicator::QUERY);
                op
            }
        }

        pub mod metric_detail {
            use super::*;
            pub fn import<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::performance::v2::metric_detail::IMPORT);
                op
            }

            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::performance::v2::metric_detail::QUERY);
                op
            }
        }

        pub mod metric_field {
            use super::*;
            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::performance::v2::metric_field::QUERY);
                op
            }
        }

        pub mod metric_lib {
            use super::*;
            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::performance::v2::metric_lib::QUERY);
                op
            }
        }

        pub mod metric_tag {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::performance::v2::metric_tag::LIST);
                op
            }
        }

        pub mod metric_template {
            use super::*;
            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::performance::v2::metric_template::QUERY);
                op
            }
        }

        pub mod question {
            use super::*;
            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::performance::v2::question::QUERY);
                op
            }
        }

        pub mod review_data {
            use super::*;
            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::performance::v2::review_data::QUERY);
                op
            }
        }

        pub mod review_template {
            use super::*;
            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::performance::v2::review_template::QUERY);
                op
            }
        }

        pub mod reviewee {
            use super::*;
            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::performance::v2::reviewee::QUERY);
                op
            }
        }

        pub mod user_group_user_rel {
            use super::*;
            pub fn write<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::performance::v2::user_group_user_rel::WRITE);
                op
            }
        }

        pub mod user_info {
            use super::*;
            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::performance::v2::user_info::QUERY);
                op
            }
        }
    }
}

pub mod personal_settings {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod system_status {
            use super::*;
            pub fn batch_close<'a>(
                client: &'a Client,
                system_status_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::personal_settings::v1::system_status::BATCH_CLOSE);
                let op = op.path_param("system_status_id", system_status_id.into());
                op
            }

            pub fn batch_open<'a>(
                client: &'a Client,
                system_status_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::personal_settings::v1::system_status::BATCH_OPEN);
                let op = op.path_param("system_status_id", system_status_id.into());
                op
            }

            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::personal_settings::v1::system_status::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                system_status_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::personal_settings::v1::system_status::DELETE);
                let op = op.path_param("system_status_id", system_status_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::personal_settings::v1::system_status::LIST);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                system_status_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::personal_settings::v1::system_status::PATCH);
                let op = op.path_param("system_status_id", system_status_id.into());
                op
            }
        }
    }
}

pub mod report {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod rule {
            use super::*;
            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::report::v1::rule::QUERY);
                op
            }
        }

        pub mod rule_view {
            use super::*;
            pub fn remove<'a>(
                client: &'a Client,
                rule_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::report::v1::rule_view::REMOVE);
                let op = op.path_param("rule_id", rule_id.into());
                op
            }
        }

        pub mod task {
            use super::*;
            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::report::v1::task::QUERY);
                op
            }
        }
    }
}

pub mod search {
    use super::*;
    pub mod v2 {
        use super::*;
        pub mod app {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::search::v2::app::CREATE);
                op
            }
        }

        pub mod data_source {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::search::v2::data_source::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                data_source_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::search::v2::data_source::DELETE);
                let op = op.path_param("data_source_id", data_source_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                data_source_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::search::v2::data_source::GET);
                let op = op.path_param("data_source_id", data_source_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::search::v2::data_source::LIST);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                data_source_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::search::v2::data_source::PATCH);
                let op = op.path_param("data_source_id", data_source_id.into());
                op
            }
        }

        pub mod data_source_item {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                data_source_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::search::v2::data_source_item::CREATE);
                let op = op.path_param("data_source_id", data_source_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                data_source_id: impl Into<String>,
                item_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::search::v2::data_source_item::DELETE);
                let op = op
                    .path_param("data_source_id", data_source_id.into())
                    .path_param("item_id", item_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                data_source_id: impl Into<String>,
                item_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::search::v2::data_source_item::GET);
                let op = op
                    .path_param("data_source_id", data_source_id.into())
                    .path_param("item_id", item_id.into());
                op
            }
        }

        pub mod doc_wiki {
            use super::*;
            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::search::v2::doc_wiki::SEARCH);
                op
            }
        }

        pub mod message {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::search::v2::message::CREATE);
                op
            }
        }

        pub mod schema {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::search::v2::schema::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                schema_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::search::v2::schema::DELETE);
                let op = op.path_param("schema_id", schema_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                schema_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::search::v2::schema::GET);
                let op = op.path_param("schema_id", schema_id.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                schema_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::search::v2::schema::PATCH);
                let op = op.path_param("schema_id", schema_id.into());
                op
            }
        }
    }
}

pub mod security_and_compliance {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod openapi_log {
            use super::*;
            pub fn list_data<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::security_and_compliance::v1::openapi_log::LIST_DATA);
                op
            }
        }
    }

    pub mod v2 {
        use super::*;
        pub mod device_apply_record {
            use super::*;
            pub fn update<'a>(
                client: &'a Client,
                device_apply_record_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op =
                    client.operation(ops::security_and_compliance::v2::device_apply_record::UPDATE);
                let op = op.path_param("device_apply_record_id", device_apply_record_id.into());
                op
            }
        }

        pub mod device_record {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::security_and_compliance::v2::device_record::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                device_record_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::security_and_compliance::v2::device_record::DELETE);
                let op = op.path_param("device_record_id", device_record_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                device_record_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::security_and_compliance::v2::device_record::GET);
                let op = op.path_param("device_record_id", device_record_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::security_and_compliance::v2::device_record::LIST);
                op
            }

            pub fn mine<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::security_and_compliance::v2::device_record::MINE);
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                device_record_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::security_and_compliance::v2::device_record::UPDATE);
                let op = op.path_param("device_record_id", device_record_id.into());
                op
            }
        }
    }
}

pub mod sheets {
    use super::*;
    pub mod v3 {
        use super::*;
        pub mod spreadsheet {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::sheets::v3::spreadsheet::CREATE);
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                spreadsheet_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::sheets::v3::spreadsheet::GET);
                let op = op.path_param("spreadsheet_token", spreadsheet_token.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                spreadsheet_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::sheets::v3::spreadsheet::PATCH);
                let op = op.path_param("spreadsheet_token", spreadsheet_token.into());
                op
            }
        }

        pub mod spreadsheet_sheet {
            use super::*;
            pub fn find<'a>(
                client: &'a Client,
                spreadsheet_token: impl Into<String>,
                sheet_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::sheets::v3::spreadsheet_sheet::FIND);
                let op = op
                    .path_param("spreadsheet_token", spreadsheet_token.into())
                    .path_param("sheet_id", sheet_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                spreadsheet_token: impl Into<String>,
                sheet_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::sheets::v3::spreadsheet_sheet::GET);
                let op = op
                    .path_param("spreadsheet_token", spreadsheet_token.into())
                    .path_param("sheet_id", sheet_id.into());
                op
            }

            pub fn move_dimension<'a>(
                client: &'a Client,
                spreadsheet_token: impl Into<String>,
                sheet_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::sheets::v3::spreadsheet_sheet::MOVE_DIMENSION);
                let op = op
                    .path_param("spreadsheet_token", spreadsheet_token.into())
                    .path_param("sheet_id", sheet_id.into());
                op
            }

            pub fn query<'a>(
                client: &'a Client,
                spreadsheet_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::sheets::v3::spreadsheet_sheet::QUERY);
                let op = op.path_param("spreadsheet_token", spreadsheet_token.into());
                op
            }

            pub fn replace<'a>(
                client: &'a Client,
                spreadsheet_token: impl Into<String>,
                sheet_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::sheets::v3::spreadsheet_sheet::REPLACE);
                let op = op
                    .path_param("spreadsheet_token", spreadsheet_token.into())
                    .path_param("sheet_id", sheet_id.into());
                op
            }
        }

        pub mod spreadsheet_sheet_filter {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                spreadsheet_token: impl Into<String>,
                sheet_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::sheets::v3::spreadsheet_sheet_filter::CREATE);
                let op = op
                    .path_param("spreadsheet_token", spreadsheet_token.into())
                    .path_param("sheet_id", sheet_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                spreadsheet_token: impl Into<String>,
                sheet_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::sheets::v3::spreadsheet_sheet_filter::DELETE);
                let op = op
                    .path_param("spreadsheet_token", spreadsheet_token.into())
                    .path_param("sheet_id", sheet_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                spreadsheet_token: impl Into<String>,
                sheet_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::sheets::v3::spreadsheet_sheet_filter::GET);
                let op = op
                    .path_param("spreadsheet_token", spreadsheet_token.into())
                    .path_param("sheet_id", sheet_id.into());
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                spreadsheet_token: impl Into<String>,
                sheet_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::sheets::v3::spreadsheet_sheet_filter::UPDATE);
                let op = op
                    .path_param("spreadsheet_token", spreadsheet_token.into())
                    .path_param("sheet_id", sheet_id.into());
                op
            }
        }

        pub mod spreadsheet_sheet_filter_view {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                spreadsheet_token: impl Into<String>,
                sheet_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::sheets::v3::spreadsheet_sheet_filter_view::CREATE);
                let op = op
                    .path_param("spreadsheet_token", spreadsheet_token.into())
                    .path_param("sheet_id", sheet_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                spreadsheet_token: impl Into<String>,
                sheet_id: impl Into<String>,
                filter_view_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::sheets::v3::spreadsheet_sheet_filter_view::DELETE);
                let op = op
                    .path_param("spreadsheet_token", spreadsheet_token.into())
                    .path_param("sheet_id", sheet_id.into())
                    .path_param("filter_view_id", filter_view_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                spreadsheet_token: impl Into<String>,
                sheet_id: impl Into<String>,
                filter_view_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::sheets::v3::spreadsheet_sheet_filter_view::GET);
                let op = op
                    .path_param("spreadsheet_token", spreadsheet_token.into())
                    .path_param("sheet_id", sheet_id.into())
                    .path_param("filter_view_id", filter_view_id.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                spreadsheet_token: impl Into<String>,
                sheet_id: impl Into<String>,
                filter_view_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::sheets::v3::spreadsheet_sheet_filter_view::PATCH);
                let op = op
                    .path_param("spreadsheet_token", spreadsheet_token.into())
                    .path_param("sheet_id", sheet_id.into())
                    .path_param("filter_view_id", filter_view_id.into());
                op
            }

            pub fn query<'a>(
                client: &'a Client,
                spreadsheet_token: impl Into<String>,
                sheet_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::sheets::v3::spreadsheet_sheet_filter_view::QUERY);
                let op = op
                    .path_param("spreadsheet_token", spreadsheet_token.into())
                    .path_param("sheet_id", sheet_id.into());
                op
            }
        }

        pub mod spreadsheet_sheet_filter_view_condition {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                spreadsheet_token: impl Into<String>,
                sheet_id: impl Into<String>,
                filter_view_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client
                    .operation(ops::sheets::v3::spreadsheet_sheet_filter_view_condition::CREATE);
                let op = op
                    .path_param("spreadsheet_token", spreadsheet_token.into())
                    .path_param("sheet_id", sheet_id.into())
                    .path_param("filter_view_id", filter_view_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                spreadsheet_token: impl Into<String>,
                sheet_id: impl Into<String>,
                filter_view_id: impl Into<String>,
                condition_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client
                    .operation(ops::sheets::v3::spreadsheet_sheet_filter_view_condition::DELETE);
                let op = op
                    .path_param("spreadsheet_token", spreadsheet_token.into())
                    .path_param("sheet_id", sheet_id.into())
                    .path_param("filter_view_id", filter_view_id.into())
                    .path_param("condition_id", condition_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                spreadsheet_token: impl Into<String>,
                sheet_id: impl Into<String>,
                filter_view_id: impl Into<String>,
                condition_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op =
                    client.operation(ops::sheets::v3::spreadsheet_sheet_filter_view_condition::GET);
                let op = op
                    .path_param("spreadsheet_token", spreadsheet_token.into())
                    .path_param("sheet_id", sheet_id.into())
                    .path_param("filter_view_id", filter_view_id.into())
                    .path_param("condition_id", condition_id.into());
                op
            }

            pub fn query<'a>(
                client: &'a Client,
                spreadsheet_token: impl Into<String>,
                sheet_id: impl Into<String>,
                filter_view_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client
                    .operation(ops::sheets::v3::spreadsheet_sheet_filter_view_condition::QUERY);
                let op = op
                    .path_param("spreadsheet_token", spreadsheet_token.into())
                    .path_param("sheet_id", sheet_id.into())
                    .path_param("filter_view_id", filter_view_id.into());
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                spreadsheet_token: impl Into<String>,
                sheet_id: impl Into<String>,
                filter_view_id: impl Into<String>,
                condition_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client
                    .operation(ops::sheets::v3::spreadsheet_sheet_filter_view_condition::UPDATE);
                let op = op
                    .path_param("spreadsheet_token", spreadsheet_token.into())
                    .path_param("sheet_id", sheet_id.into())
                    .path_param("filter_view_id", filter_view_id.into())
                    .path_param("condition_id", condition_id.into());
                op
            }
        }

        pub mod spreadsheet_sheet_float_image {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                spreadsheet_token: impl Into<String>,
                sheet_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::sheets::v3::spreadsheet_sheet_float_image::CREATE);
                let op = op
                    .path_param("spreadsheet_token", spreadsheet_token.into())
                    .path_param("sheet_id", sheet_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                spreadsheet_token: impl Into<String>,
                sheet_id: impl Into<String>,
                float_image_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::sheets::v3::spreadsheet_sheet_float_image::DELETE);
                let op = op
                    .path_param("spreadsheet_token", spreadsheet_token.into())
                    .path_param("sheet_id", sheet_id.into())
                    .path_param("float_image_id", float_image_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                spreadsheet_token: impl Into<String>,
                sheet_id: impl Into<String>,
                float_image_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::sheets::v3::spreadsheet_sheet_float_image::GET);
                let op = op
                    .path_param("spreadsheet_token", spreadsheet_token.into())
                    .path_param("sheet_id", sheet_id.into())
                    .path_param("float_image_id", float_image_id.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                spreadsheet_token: impl Into<String>,
                sheet_id: impl Into<String>,
                float_image_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::sheets::v3::spreadsheet_sheet_float_image::PATCH);
                let op = op
                    .path_param("spreadsheet_token", spreadsheet_token.into())
                    .path_param("sheet_id", sheet_id.into())
                    .path_param("float_image_id", float_image_id.into());
                op
            }

            pub fn query<'a>(
                client: &'a Client,
                spreadsheet_token: impl Into<String>,
                sheet_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::sheets::v3::spreadsheet_sheet_float_image::QUERY);
                let op = op
                    .path_param("spreadsheet_token", spreadsheet_token.into())
                    .path_param("sheet_id", sheet_id.into());
                op
            }
        }
    }
}

pub mod speech_to_text {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod speech {
            use super::*;
            pub fn file_recognize<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::speech_to_text::v1::speech::FILE_RECOGNIZE);
                op
            }

            pub fn stream_recognize<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::speech_to_text::v1::speech::STREAM_RECOGNIZE);
                op
            }
        }
    }
}

pub mod task {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod task {
            use super::*;
            pub fn batch_delete_collaborator<'a>(
                client: &'a Client,
                task_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v1::task::BATCH_DELETE_COLLABORATOR);
                let op = op.path_param("task_id", task_id.into());
                op
            }

            pub fn batch_delete_follower<'a>(
                client: &'a Client,
                task_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v1::task::BATCH_DELETE_FOLLOWER);
                let op = op.path_param("task_id", task_id.into());
                op
            }

            pub fn complete<'a>(
                client: &'a Client,
                task_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v1::task::COMPLETE);
                let op = op.path_param("task_id", task_id.into());
                op
            }

            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v1::task::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                task_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v1::task::DELETE);
                let op = op.path_param("task_id", task_id.into());
                op
            }

            pub fn get<'a>(client: &'a Client, task_id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v1::task::GET);
                let op = op.path_param("task_id", task_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v1::task::LIST);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                task_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v1::task::PATCH);
                let op = op.path_param("task_id", task_id.into());
                op
            }

            pub fn uncomplete<'a>(
                client: &'a Client,
                task_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v1::task::UNCOMPLETE);
                let op = op.path_param("task_id", task_id.into());
                op
            }
        }

        pub mod task_collaborator {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                task_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v1::task_collaborator::CREATE);
                let op = op.path_param("task_id", task_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                task_id: impl Into<String>,
                collaborator_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v1::task_collaborator::DELETE);
                let op = op
                    .path_param("task_id", task_id.into())
                    .path_param("collaborator_id", collaborator_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                task_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v1::task_collaborator::LIST);
                let op = op.path_param("task_id", task_id.into());
                op
            }
        }

        pub mod task_comment {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                task_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v1::task_comment::CREATE);
                let op = op.path_param("task_id", task_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                task_id: impl Into<String>,
                comment_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v1::task_comment::DELETE);
                let op = op
                    .path_param("task_id", task_id.into())
                    .path_param("comment_id", comment_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                task_id: impl Into<String>,
                comment_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v1::task_comment::GET);
                let op = op
                    .path_param("task_id", task_id.into())
                    .path_param("comment_id", comment_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                task_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v1::task_comment::LIST);
                let op = op.path_param("task_id", task_id.into());
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                task_id: impl Into<String>,
                comment_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v1::task_comment::UPDATE);
                let op = op
                    .path_param("task_id", task_id.into())
                    .path_param("comment_id", comment_id.into());
                op
            }
        }

        pub mod task_follower {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                task_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v1::task_follower::CREATE);
                let op = op.path_param("task_id", task_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                task_id: impl Into<String>,
                follower_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v1::task_follower::DELETE);
                let op = op
                    .path_param("task_id", task_id.into())
                    .path_param("follower_id", follower_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                task_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v1::task_follower::LIST);
                let op = op.path_param("task_id", task_id.into());
                op
            }
        }

        pub mod task_reminder {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                task_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v1::task_reminder::CREATE);
                let op = op.path_param("task_id", task_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                task_id: impl Into<String>,
                reminder_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v1::task_reminder::DELETE);
                let op = op
                    .path_param("task_id", task_id.into())
                    .path_param("reminder_id", reminder_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                task_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v1::task_reminder::LIST);
                let op = op.path_param("task_id", task_id.into());
                op
            }
        }
    }

    pub mod v2 {
        use super::*;
        pub mod attachment {
            use super::*;
            pub fn delete<'a>(
                client: &'a Client,
                attachment_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::attachment::DELETE);
                let op = op.path_param("attachment_guid", attachment_guid.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                attachment_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::attachment::GET);
                let op = op.path_param("attachment_guid", attachment_guid.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::attachment::LIST);
                op
            }

            pub fn upload<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::attachment::UPLOAD);
                op
            }
        }

        pub mod comment {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::comment::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                comment_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::comment::DELETE);
                let op = op.path_param("comment_id", comment_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                comment_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::comment::GET);
                let op = op.path_param("comment_id", comment_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::comment::LIST);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                comment_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::comment::PATCH);
                let op = op.path_param("comment_id", comment_id.into());
                op
            }
        }

        pub mod custom_field {
            use super::*;
            pub fn add<'a>(
                client: &'a Client,
                custom_field_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::custom_field::ADD);
                let op = op.path_param("custom_field_guid", custom_field_guid.into());
                op
            }

            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::custom_field::CREATE);
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                custom_field_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::custom_field::GET);
                let op = op.path_param("custom_field_guid", custom_field_guid.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::custom_field::LIST);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                custom_field_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::custom_field::PATCH);
                let op = op.path_param("custom_field_guid", custom_field_guid.into());
                op
            }

            pub fn remove<'a>(
                client: &'a Client,
                custom_field_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::custom_field::REMOVE);
                let op = op.path_param("custom_field_guid", custom_field_guid.into());
                op
            }
        }

        pub mod custom_field_option {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                custom_field_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::custom_field_option::CREATE);
                let op = op.path_param("custom_field_guid", custom_field_guid.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                custom_field_guid: impl Into<String>,
                option_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::custom_field_option::PATCH);
                let op = op
                    .path_param("custom_field_guid", custom_field_guid.into())
                    .path_param("option_guid", option_guid.into());
                op
            }
        }

        pub mod section {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::section::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                section_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::section::DELETE);
                let op = op.path_param("section_guid", section_guid.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                section_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::section::GET);
                let op = op.path_param("section_guid", section_guid.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::section::LIST);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                section_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::section::PATCH);
                let op = op.path_param("section_guid", section_guid.into());
                op
            }

            pub fn tasks<'a>(
                client: &'a Client,
                section_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::section::TASKS);
                let op = op.path_param("section_guid", section_guid.into());
                op
            }
        }

        pub mod task {
            use super::*;
            pub fn add_dependencies<'a>(
                client: &'a Client,
                task_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::task::ADD_DEPENDENCIES);
                let op = op.path_param("task_guid", task_guid.into());
                op
            }

            pub fn add_members<'a>(
                client: &'a Client,
                task_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::task::ADD_MEMBERS);
                let op = op.path_param("task_guid", task_guid.into());
                op
            }

            pub fn add_reminders<'a>(
                client: &'a Client,
                task_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::task::ADD_REMINDERS);
                let op = op.path_param("task_guid", task_guid.into());
                op
            }

            pub fn add_tasklist<'a>(
                client: &'a Client,
                task_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::task::ADD_TASKLIST);
                let op = op.path_param("task_guid", task_guid.into());
                op
            }

            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::task::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                task_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::task::DELETE);
                let op = op.path_param("task_guid", task_guid.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                task_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::task::GET);
                let op = op.path_param("task_guid", task_guid.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::task::LIST);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                task_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::task::PATCH);
                let op = op.path_param("task_guid", task_guid.into());
                op
            }

            pub fn remove_dependencies<'a>(
                client: &'a Client,
                task_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::task::REMOVE_DEPENDENCIES);
                let op = op.path_param("task_guid", task_guid.into());
                op
            }

            pub fn remove_members<'a>(
                client: &'a Client,
                task_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::task::REMOVE_MEMBERS);
                let op = op.path_param("task_guid", task_guid.into());
                op
            }

            pub fn remove_reminders<'a>(
                client: &'a Client,
                task_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::task::REMOVE_REMINDERS);
                let op = op.path_param("task_guid", task_guid.into());
                op
            }

            pub fn remove_tasklist<'a>(
                client: &'a Client,
                task_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::task::REMOVE_TASKLIST);
                let op = op.path_param("task_guid", task_guid.into());
                op
            }

            pub fn tasklists<'a>(
                client: &'a Client,
                task_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::task::TASKLISTS);
                let op = op.path_param("task_guid", task_guid.into());
                op
            }
        }

        pub mod task_subtask {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                task_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::task_subtask::CREATE);
                let op = op.path_param("task_guid", task_guid.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                task_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::task_subtask::LIST);
                let op = op.path_param("task_guid", task_guid.into());
                op
            }
        }

        pub mod tasklist {
            use super::*;
            pub fn add_members<'a>(
                client: &'a Client,
                tasklist_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::tasklist::ADD_MEMBERS);
                let op = op.path_param("tasklist_guid", tasklist_guid.into());
                op
            }

            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::tasklist::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                tasklist_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::tasklist::DELETE);
                let op = op.path_param("tasklist_guid", tasklist_guid.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                tasklist_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::tasklist::GET);
                let op = op.path_param("tasklist_guid", tasklist_guid.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::tasklist::LIST);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                tasklist_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::tasklist::PATCH);
                let op = op.path_param("tasklist_guid", tasklist_guid.into());
                op
            }

            pub fn remove_members<'a>(
                client: &'a Client,
                tasklist_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::tasklist::REMOVE_MEMBERS);
                let op = op.path_param("tasklist_guid", tasklist_guid.into());
                op
            }

            pub fn tasks<'a>(
                client: &'a Client,
                tasklist_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::tasklist::TASKS);
                let op = op.path_param("tasklist_guid", tasklist_guid.into());
                op
            }
        }

        pub mod tasklist_activity_subscription {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                tasklist_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::tasklist_activity_subscription::CREATE);
                let op = op.path_param("tasklist_guid", tasklist_guid.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                tasklist_guid: impl Into<String>,
                activity_subscription_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::tasklist_activity_subscription::DELETE);
                let op = op
                    .path_param("tasklist_guid", tasklist_guid.into())
                    .path_param(
                        "activity_subscription_guid",
                        activity_subscription_guid.into(),
                    );
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                tasklist_guid: impl Into<String>,
                activity_subscription_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::tasklist_activity_subscription::GET);
                let op = op
                    .path_param("tasklist_guid", tasklist_guid.into())
                    .path_param(
                        "activity_subscription_guid",
                        activity_subscription_guid.into(),
                    );
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                tasklist_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::tasklist_activity_subscription::LIST);
                let op = op.path_param("tasklist_guid", tasklist_guid.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                tasklist_guid: impl Into<String>,
                activity_subscription_guid: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::task::v2::tasklist_activity_subscription::PATCH);
                let op = op
                    .path_param("tasklist_guid", tasklist_guid.into())
                    .path_param(
                        "activity_subscription_guid",
                        activity_subscription_guid.into(),
                    );
                op
            }
        }
    }
}

pub mod tenant {
    use super::*;
    pub mod v2 {
        use super::*;
        pub mod tenant {
            use super::*;
            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::tenant::v2::tenant::QUERY);
                op
            }
        }

        pub mod tenant_product_assign_info {
            use super::*;
            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::tenant::v2::tenant_product_assign_info::QUERY);
                op
            }
        }
    }
}

pub mod translation {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod text {
            use super::*;
            pub fn detect<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::translation::v1::text::DETECT);
                op
            }

            pub fn translate<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::translation::v1::text::TRANSLATE);
                op
            }
        }
    }
}

pub mod vc {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod alert {
            use super::*;
            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::alert::LIST);
                op
            }
        }

        pub mod export {
            use super::*;
            pub fn download<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::export::DOWNLOAD);
                op
            }

            pub fn get<'a>(client: &'a Client, task_id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::export::GET);
                let op = op.path_param("task_id", task_id.into());
                op
            }

            pub fn meeting_list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::export::MEETING_LIST);
                op
            }

            pub fn participant_list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::export::PARTICIPANT_LIST);
                op
            }

            pub fn participant_quality_list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::export::PARTICIPANT_QUALITY_LIST);
                op
            }

            pub fn resource_reservation_list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::export::RESOURCE_RESERVATION_LIST);
                op
            }
        }

        pub mod meeting {
            use super::*;
            pub fn end<'a>(
                client: &'a Client,
                meeting_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::meeting::END);
                let op = op.path_param("meeting_id", meeting_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                meeting_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::meeting::GET);
                let op = op.path_param("meeting_id", meeting_id.into());
                op
            }

            pub fn invite<'a>(
                client: &'a Client,
                meeting_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::meeting::INVITE);
                let op = op.path_param("meeting_id", meeting_id.into());
                op
            }

            pub fn kickout<'a>(
                client: &'a Client,
                meeting_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::meeting::KICKOUT);
                let op = op.path_param("meeting_id", meeting_id.into());
                op
            }

            pub fn list_by_no<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::meeting::LIST_BY_NO);
                op
            }

            pub fn set_host<'a>(
                client: &'a Client,
                meeting_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::meeting::SET_HOST);
                let op = op.path_param("meeting_id", meeting_id.into());
                op
            }
        }

        pub mod meeting_list {
            use super::*;
            pub fn get<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::meeting_list::GET);
                op
            }
        }

        pub mod meeting_recording {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                meeting_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::meeting_recording::GET);
                let op = op.path_param("meeting_id", meeting_id.into());
                op
            }

            pub fn set_permission<'a>(
                client: &'a Client,
                meeting_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::meeting_recording::SET_PERMISSION);
                let op = op.path_param("meeting_id", meeting_id.into());
                op
            }

            pub fn start<'a>(
                client: &'a Client,
                meeting_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::meeting_recording::START);
                let op = op.path_param("meeting_id", meeting_id.into());
                op
            }

            pub fn stop<'a>(
                client: &'a Client,
                meeting_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::meeting_recording::STOP);
                let op = op.path_param("meeting_id", meeting_id.into());
                op
            }
        }

        pub mod participant_list {
            use super::*;
            pub fn get<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::participant_list::GET);
                op
            }
        }

        pub mod participant_quality_list {
            use super::*;
            pub fn get<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::participant_quality_list::GET);
                op
            }
        }

        pub mod report {
            use super::*;
            pub fn get_daily<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::report::GET_DAILY);
                op
            }

            pub fn get_top_user<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::report::GET_TOP_USER);
                op
            }
        }

        pub mod reserve {
            use super::*;
            pub fn apply<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::reserve::APPLY);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                reserve_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::reserve::DELETE);
                let op = op.path_param("reserve_id", reserve_id.into());
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                reserve_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::reserve::GET);
                let op = op.path_param("reserve_id", reserve_id.into());
                op
            }

            pub fn get_active_meeting<'a>(
                client: &'a Client,
                reserve_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::reserve::GET_ACTIVE_MEETING);
                let op = op.path_param("reserve_id", reserve_id.into());
                op
            }

            pub fn update<'a>(
                client: &'a Client,
                reserve_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::reserve::UPDATE);
                let op = op.path_param("reserve_id", reserve_id.into());
                op
            }
        }

        pub mod reserve_config {
            use super::*;
            pub fn patch<'a>(
                client: &'a Client,
                reserve_config_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::reserve_config::PATCH);
                let op = op.path_param("reserve_config_id", reserve_config_id.into());
                op
            }

            pub fn reserve_scope<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::reserve_config::RESERVE_SCOPE);
                op
            }
        }

        pub mod reserve_config_admin {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                reserve_config_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::reserve_config_admin::GET);
                let op = op.path_param("reserve_config_id", reserve_config_id.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                reserve_config_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::reserve_config_admin::PATCH);
                let op = op.path_param("reserve_config_id", reserve_config_id.into());
                op
            }
        }

        pub mod reserve_config_disable_inform {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                reserve_config_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::reserve_config_disable_inform::GET);
                let op = op.path_param("reserve_config_id", reserve_config_id.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                reserve_config_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::reserve_config_disable_inform::PATCH);
                let op = op.path_param("reserve_config_id", reserve_config_id.into());
                op
            }
        }

        pub mod reserve_config_form {
            use super::*;
            pub fn get<'a>(
                client: &'a Client,
                reserve_config_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::reserve_config_form::GET);
                let op = op.path_param("reserve_config_id", reserve_config_id.into());
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                reserve_config_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::reserve_config_form::PATCH);
                let op = op.path_param("reserve_config_id", reserve_config_id.into());
                op
            }
        }

        pub mod resource_reservation_list {
            use super::*;
            pub fn get<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::resource_reservation_list::GET);
                op
            }
        }

        pub mod room {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::room::CREATE);
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                room_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::room::DELETE);
                let op = op.path_param("room_id", room_id.into());
                op
            }

            pub fn get<'a>(client: &'a Client, room_id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::room::GET);
                let op = op.path_param("room_id", room_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::room::LIST);
                op
            }

            pub fn mget<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::room::MGET);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                room_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::room::PATCH);
                let op = op.path_param("room_id", room_id.into());
                op
            }

            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::room::SEARCH);
                op
            }
        }

        pub mod room_config {
            use super::*;
            pub fn query<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::room_config::QUERY);
                op
            }

            pub fn set<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::room_config::SET);
                op
            }

            pub fn set_checkboard_access_code<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::room_config::SET_CHECKBOARD_ACCESS_CODE);
                op
            }

            pub fn set_room_access_code<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::room_config::SET_ROOM_ACCESS_CODE);
                op
            }
        }

        pub mod room_level {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::room_level::CREATE);
                op
            }

            pub fn del<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::room_level::DEL);
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                room_level_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::room_level::GET);
                let op = op.path_param("room_level_id", room_level_id.into());
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::room_level::LIST);
                op
            }

            pub fn mget<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::room_level::MGET);
                op
            }

            pub fn patch<'a>(
                client: &'a Client,
                room_level_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::room_level::PATCH);
                let op = op.path_param("room_level_id", room_level_id.into());
                op
            }

            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::room_level::SEARCH);
                op
            }
        }

        pub mod scope_config {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::scope_config::CREATE);
                op
            }

            pub fn get<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::vc::v1::scope_config::GET);
                op
            }
        }
    }
}

pub mod verification {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod verification {
            use super::*;
            pub fn get<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::verification::v1::verification::GET);
                op
            }
        }
    }
}

pub mod wiki {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod node {
            use super::*;
            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::wiki::v1::node::SEARCH);
                op
            }
        }
    }

    pub mod v2 {
        use super::*;
        pub mod space {
            use super::*;
            pub fn create<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::wiki::v2::space::CREATE);
                op
            }

            pub fn get<'a>(
                client: &'a Client,
                space_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::wiki::v2::space::GET);
                let op = op.path_param("space_id", space_id.into());
                op
            }

            pub fn get_node<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::wiki::v2::space::GET_NODE);
                op
            }

            pub fn list<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::wiki::v2::space::LIST);
                op
            }
        }

        pub mod space_member {
            use super::*;
            pub fn create<'a>(
                client: &'a Client,
                space_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::wiki::v2::space_member::CREATE);
                let op = op.path_param("space_id", space_id.into());
                op
            }

            pub fn delete<'a>(
                client: &'a Client,
                space_id: impl Into<String>,
                member_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::wiki::v2::space_member::DELETE);
                let op = op
                    .path_param("space_id", space_id.into())
                    .path_param("member_id", member_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                space_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::wiki::v2::space_member::LIST);
                let op = op.path_param("space_id", space_id.into());
                op
            }
        }

        pub mod space_node {
            use super::*;
            pub fn copy<'a>(
                client: &'a Client,
                space_id: impl Into<String>,
                node_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::wiki::v2::space_node::COPY);
                let op = op
                    .path_param("space_id", space_id.into())
                    .path_param("node_token", node_token.into());
                op
            }

            pub fn create<'a>(
                client: &'a Client,
                space_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::wiki::v2::space_node::CREATE);
                let op = op.path_param("space_id", space_id.into());
                op
            }

            pub fn list<'a>(
                client: &'a Client,
                space_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::wiki::v2::space_node::LIST);
                let op = op.path_param("space_id", space_id.into());
                op
            }

            pub fn move_<'a>(
                client: &'a Client,
                space_id: impl Into<String>,
                node_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::wiki::v2::space_node::MOVE);
                let op = op
                    .path_param("space_id", space_id.into())
                    .path_param("node_token", node_token.into());
                op
            }

            pub fn move_docs_to_wiki<'a>(
                client: &'a Client,
                space_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::wiki::v2::space_node::MOVE_DOCS_TO_WIKI);
                let op = op.path_param("space_id", space_id.into());
                op
            }

            pub fn update_title<'a>(
                client: &'a Client,
                space_id: impl Into<String>,
                node_token: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::wiki::v2::space_node::UPDATE_TITLE);
                let op = op
                    .path_param("space_id", space_id.into())
                    .path_param("node_token", node_token.into());
                op
            }
        }

        pub mod space_setting {
            use super::*;
            pub fn update<'a>(
                client: &'a Client,
                space_id: impl Into<String>,
            ) -> OperationBuilder<'a> {
                let op = client.operation(ops::wiki::v2::space_setting::UPDATE);
                let op = op.path_param("space_id", space_id.into());
                op
            }
        }

        pub mod task {
            use super::*;
            pub fn get<'a>(client: &'a Client, task_id: impl Into<String>) -> OperationBuilder<'a> {
                let op = client.operation(ops::wiki::v2::task::GET);
                let op = op.path_param("task_id", task_id.into());
                op
            }
        }
    }
}

pub mod workplace {
    use super::*;
    pub mod v1 {
        use super::*;
        pub mod custom_workplace_access_data {
            use super::*;
            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::workplace::v1::custom_workplace_access_data::SEARCH);
                op
            }
        }

        pub mod workplace_access_data {
            use super::*;
            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::workplace::v1::workplace_access_data::SEARCH);
                op
            }
        }

        pub mod workplace_block_access_data {
            use super::*;
            pub fn search<'a>(client: &'a Client) -> OperationBuilder<'a> {
                let op = client.operation(ops::workplace::v1::workplace_block_access_data::SEARCH);
                op
            }
        }
    }
}
