// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

use crate::*;
use pyo3_stub_gen::{derive::*, inventory::submit, module_doc};

module_doc!(
    "opendal.services",
    r#"
Services.

>> DO NOT EDIT THIS FILE MANUALLY <<

This file is automatically generated by just recipe with name `stub-gen`
alongwith the rest of the stubs.

See justfile at path ``../../justfile`` for more details.
"#
);

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        class Operator:
            @overload
            def __new__(cls,
                scheme: builtins.str,
                /,
                **kwargs: builtins.str,
            ) -> typing.Self: ...
        "#
    }
}

#[gen_stub_pyclass_enum]
#[pyclass(
    eq,
    eq_int,
    dict,
    hash,
    frozen,
    name = "Scheme",
    module = "opendal.services"
)]
#[pyo3(rename_all = "PascalCase")]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum PyScheme {
    #[cfg(feature = "services-aliyun-drive")]
    AliyunDrive,
    #[cfg(feature = "services-alluxio")]
    Alluxio,
    #[cfg(feature = "services-azblob")]
    Azblob,
    #[cfg(feature = "services-azdls")]
    Azdls,
    #[cfg(feature = "services-azfile")]
    Azfile,
    #[cfg(feature = "services-b2")]
    B2,
    #[cfg(feature = "services-cacache")]
    Cacache,
    #[cfg(feature = "services-cloudflare-kv")]
    CloudflareKv,
    #[cfg(feature = "services-cos")]
    Cos,
    #[cfg(feature = "services-dashmap")]
    Dashmap,
    #[cfg(feature = "services-dropbox")]
    Dropbox,
    #[cfg(feature = "services-fs")]
    Fs,
    #[cfg(feature = "services-ftp")]
    Ftp,
    #[cfg(feature = "services-gcs")]
    Gcs,
    #[cfg(feature = "services-gdrive")]
    Gdrive,
    #[cfg(feature = "services-ghac")]
    Ghac,
    #[cfg(feature = "services-goosefs")]
    Goosefs,
    #[cfg(feature = "services-gridfs")]
    Gridfs,
    #[cfg(feature = "services-hdfs-native")]
    HdfsNative,
    #[cfg(feature = "services-hf")]
    Hf,
    #[cfg(feature = "services-http")]
    Http,
    #[cfg(feature = "services-ipfs")]
    Ipfs,
    #[cfg(feature = "services-ipmfs")]
    Ipmfs,
    #[cfg(feature = "services-koofr")]
    Koofr,
    #[cfg(feature = "services-memcached")]
    Memcached,
    #[cfg(feature = "services-memory")]
    Memory,
    #[cfg(feature = "services-mini-moka")]
    MiniMoka,
    #[cfg(feature = "services-moka")]
    Moka,
    #[cfg(feature = "services-mongodb")]
    Mongodb,
    #[cfg(feature = "services-mysql")]
    Mysql,
    #[cfg(feature = "services-obs")]
    Obs,
    #[cfg(feature = "services-onedrive")]
    Onedrive,
    #[cfg(feature = "services-oss")]
    Oss,
    #[cfg(feature = "services-persy")]
    Persy,
    #[cfg(feature = "services-postgresql")]
    Postgresql,
    #[cfg(feature = "services-redb")]
    Redb,
    #[cfg(feature = "services-redis")]
    Redis,
    #[cfg(feature = "services-s3")]
    S3,
    #[cfg(feature = "services-seafile")]
    Seafile,
    #[cfg(feature = "services-sftp")]
    Sftp,
    #[cfg(feature = "services-sled")]
    Sled,
    #[cfg(feature = "services-sqlite")]
    Sqlite,
    #[cfg(feature = "services-swift")]
    Swift,
    #[cfg(feature = "services-tos")]
    Tos,
    #[cfg(feature = "services-upyun")]
    Upyun,
    #[cfg(feature = "services-vercel-artifacts")]
    VercelArtifacts,
    #[cfg(feature = "services-vercel-blob")]
    VercelBlob,
    #[cfg(feature = "services-webdav")]
    Webdav,
    #[cfg(feature = "services-webhdfs")]
    Webhdfs,
    #[cfg(feature = "services-yandex-disk")]
    YandexDisk,
}

#[gen_stub_pymethods]
#[pymethods]
impl PyScheme {
    #[getter]
    pub fn name(&self) -> String {
        format!("{:?}", &self)
    }

    #[getter]
    pub fn value(&self) -> &'static str {
        (*self).into()
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.AliyunDrive, "aliyun-drive"],
                /,
                *,
                access_token: builtins.str = ...,
                client_id: builtins.str = ...,
                client_secret: builtins.str = ...,
                drive_type: builtins.str,
                refresh_token: builtins.str = ...,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `aliyun-drive` service.

                Parameters
                ----------
                access_token : builtins.str, optional
                    The access_token of this backend.
                    Solution for client-only purpose.
                    #4733 Required if no client_id, client_secret and
                    refresh_token are provided.
                client_id : builtins.str, optional
                    The client_id of this backend.
                    Required if no access_token is provided.
                client_secret : builtins.str, optional
                    The client_secret of this backend.
                    Required if no access_token is provided.
                drive_type : builtins.str
                    The drive_type of this backend.
                    All operations will happen under this type of drive.
                    Available values are `default`, `backup` and
                    `resource`.
                    Fallback to default if not set or no other drives
                    can be found.
                refresh_token : builtins.str, optional
                    The refresh_token of this backend.
                    Required if no access_token is provided.
                root : builtins.str, optional
                    The Root of this backend.
                    All operations will happen under this root.
                    Default to `/` if not set.
                Returns
                -------
                Operator
                    The new `Operator` for `aliyun-drive` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Alluxio, "alluxio"],
                /,
                *,
                endpoint: builtins.str = ...,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `alluxio` service.

                Parameters
                ----------
                endpoint : builtins.str, optional
                    endpoint of this backend.
                    Endpoint must be full uri, mostly like
                    `http://127.0.0.1:39999`.
                root : builtins.str, optional
                    root of this backend.
                    All operations will happen under this root.
                    default to `/` if not set.
                Returns
                -------
                Operator
                    The new `Operator` for `alluxio` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Azblob, "azblob"],
                /,
                *,
                account_key: builtins.str = ...,
                account_name: builtins.str = ...,
                batch_max_operations: builtins.int = ...,
                container: builtins.str,
                encryption_algorithm: builtins.str = ...,
                encryption_key: builtins.str = ...,
                encryption_key_sha256: builtins.str = ...,
                endpoint: builtins.str = ...,
                root: builtins.str = ...,
                sas_token: builtins.str = ...,
                skip_signature: builtins.bool = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `azblob` service.

                Parameters
                ----------
                account_key : builtins.str, optional
                    The account key of Azblob service backend.
                account_name : builtins.str, optional
                    The account name of Azblob service backend.
                batch_max_operations : builtins.int, optional
                    Deprecated: Azblob delete batch capability is
                    enabled by default with Azure Blob's 256-operation
                    batch limit.
                container : builtins.str
                    The container name of Azblob service backend.
                encryption_algorithm : builtins.str, optional
                    The encryption algorithm of Azblob service backend.
                encryption_key : builtins.str, optional
                    The encryption key of Azblob service backend.
                encryption_key_sha256 : builtins.str, optional
                    The encryption key sha256 of Azblob service backend.
                endpoint : builtins.str, optional
                    The endpoint of Azblob service backend.
                    Endpoint must be full uri, e.g.
                    - Azblob:
                    `https://accountname.blob.core.windows.net` -
                    Azurite: `http://127.0.0.1:10000/devstoreaccount1`
                root : builtins.str, optional
                    The root of Azblob service backend.
                    All operations will happen under this root.
                sas_token : builtins.str, optional
                    The sas token of Azblob service backend.
                skip_signature : builtins.bool, optional
                    Skip signature will skip loading credentials and
                    signing requests.
                Returns
                -------
                Operator
                    The new `Operator` for `azblob` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Azdls, "azdls"],
                /,
                *,
                account_key: builtins.str = ...,
                account_name: builtins.str = ...,
                authority_host: builtins.str = ...,
                client_id: builtins.str = ...,
                client_secret: builtins.str = ...,
                enable_hns: builtins.bool = ...,
                endpoint: builtins.str = ...,
                filesystem: builtins.str,
                root: builtins.str = ...,
                sas_token: builtins.str = ...,
                tenant_id: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `azdls` service.

                Parameters
                ----------
                account_key : builtins.str, optional
                    Account key of this backend.
                    - required for shared_key authentication
                account_name : builtins.str, optional
                    Account name of this backend.
                authority_host : builtins.str, optional
                    authority_host The authority host of the service
                    principal.
                    - required for client_credentials authentication -
                    default value: `https://login.microsoftonline.com`
                client_id : builtins.str, optional
                    client_id The client id of the service principal.
                    - required for client_credentials authentication
                client_secret : builtins.str, optional
                    client_secret The client secret of the service
                    principal.
                    - required for client_credentials authentication
                enable_hns : builtins.bool, optional
                    Whether hierarchical namespace (HNS) is enabled for
                    the storage account.
                    When enabled, recursive deletion can use pagination
                    to avoid timeouts on large directories.
                    - default value: `false`
                endpoint : builtins.str, optional
                    Endpoint of this backend.
                filesystem : builtins.str
                    Filesystem name of this backend.
                root : builtins.str, optional
                    Root of this backend.
                sas_token : builtins.str, optional
                    sas_token The shared access signature token.
                    - required for sas authentication
                tenant_id : builtins.str, optional
                    tenant_id The tenant id of the service principal.
                    - required for client_credentials authentication
                Returns
                -------
                Operator
                    The new `Operator` for `azdls` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Azfile, "azfile"],
                /,
                *,
                account_key: builtins.str = ...,
                account_name: builtins.str = ...,
                endpoint: builtins.str = ...,
                root: builtins.str = ...,
                sas_token: builtins.str = ...,
                share_name: builtins.str,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `azfile` service.

                Parameters
                ----------
                account_key : builtins.str, optional
                    The account key for azfile.
                account_name : builtins.str, optional
                    The account name for azfile.
                endpoint : builtins.str, optional
                    The endpoint for azfile.
                root : builtins.str, optional
                    The root path for azfile.
                sas_token : builtins.str, optional
                    The sas token for azfile.
                share_name : builtins.str
                    The share name for azfile.
                Returns
                -------
                Operator
                    The new `Operator` for `azfile` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.B2, "b2"],
                /,
                *,
                application_key: builtins.str = ...,
                application_key_id: builtins.str = ...,
                bucket: builtins.str,
                bucket_id: builtins.str,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `b2` service.

                Parameters
                ----------
                application_key : builtins.str, optional
                    applicationKey of this backend.
                    - If application_key is set, we will take user's
                    input first.
                    - If not, we will try to load it from environment.
                application_key_id : builtins.str, optional
                    keyID of this backend.
                    - If application_key_id is set, we will take user's
                    input first.
                    - If not, we will try to load it from environment.
                bucket : builtins.str
                    bucket of this backend.
                    required.
                bucket_id : builtins.str
                    bucket id of this backend.
                    required.
                root : builtins.str, optional
                    root of this backend.
                    All operations will happen under this root.
                Returns
                -------
                Operator
                    The new `Operator` for `b2` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Cacache, "cacache"],
                /,
                *,
                datadir: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `cacache` service.

                Parameters
                ----------
                datadir : builtins.str, optional
                    That path to the cacache data directory.
                Returns
                -------
                Operator
                    The new `Operator` for `cacache` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.CloudflareKv, "cloudflare-kv"],
                /,
                *,
                account_id: builtins.str = ...,
                api_token: builtins.str = ...,
                default_ttl: typing.Any = ...,
                namespace_id: builtins.str = ...,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `cloudflare-kv` service.

                Parameters
                ----------
                account_id : builtins.str, optional
                    The account ID used to authenticate with CloudFlare.
                    Used as URI path parameter.
                api_token : builtins.str, optional
                    The token used to authenticate with CloudFlare.
                default_ttl : typing.Any, optional
                    The default ttl for write operations..
                    a human readable duration string see
                    https://docs.rs/humantime/latest/humantime/fn.parse_duration.html
                    for more details
                namespace_id : builtins.str, optional
                    The namespace ID.
                    Used as URI path parameter.
                root : builtins.str, optional
                    Root within this backend.
                Returns
                -------
                Operator
                    The new `Operator` for `cloudflare-kv` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Cos, "cos"],
                /,
                *,
                bucket: builtins.str = ...,
                disable_config_load: builtins.bool = ...,
                enable_versioning: builtins.bool = ...,
                endpoint: builtins.str = ...,
                root: builtins.str = ...,
                secret_id: builtins.str = ...,
                secret_key: builtins.str = ...,
                security_token: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `cos` service.

                Parameters
                ----------
                bucket : builtins.str, optional
                    Bucket of this backend.
                disable_config_load : builtins.bool, optional
                    Disable config load so that opendal will not load
                    config from
                enable_versioning : builtins.bool, optional
                    Deprecated: COS versioning capability is enabled by
                    default.
                endpoint : builtins.str, optional
                    Endpoint of this backend.
                root : builtins.str, optional
                    Root of this backend.
                secret_id : builtins.str, optional
                    Secret ID of this backend.
                secret_key : builtins.str, optional
                    Secret key of this backend.
                security_token : builtins.str, optional
                    Security token (a.k.a.
                    session token) of this backend.
                    This is used for temporary credentials issued by
                    Tencent Cloud STS (e.g.
                    `GetFederationToken` / `AssumeRole`).
                    When `security_token` is provided, it will be used
                    together with `secret_id` and `secret_key` to sign
                    requests, and the `x-cos-security-token` header will
                    be attached automatically by the signer.
                    If this field is not set, OpenDAL will also fall
                    back to reading the token from environment variables
                    `TENCENTCLOUD_TOKEN`, `TENCENTCLOUD_SECURITY_TOKEN`
                    or `QCLOUD_SECRET_TOKEN` (unless
                    `disable_config_load` is enabled).
                Returns
                -------
                Operator
                    The new `Operator` for `cos` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Dashmap, "dashmap"],
                /,
                *,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `dashmap` service.

                Parameters
                ----------
                root : builtins.str, optional
                    root path of this backend
                Returns
                -------
                Operator
                    The new `Operator` for `dashmap` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Dropbox, "dropbox"],
                /,
                *,
                access_token: builtins.str = ...,
                client_id: builtins.str = ...,
                client_secret: builtins.str = ...,
                refresh_token: builtins.str = ...,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `dropbox` service.

                Parameters
                ----------
                access_token : builtins.str, optional
                    access token for dropbox.
                client_id : builtins.str, optional
                    client_id for dropbox.
                client_secret : builtins.str, optional
                    client_secret for dropbox.
                refresh_token : builtins.str, optional
                    refresh_token for dropbox.
                root : builtins.str, optional
                    root path for dropbox.
                Returns
                -------
                Operator
                    The new `Operator` for `dropbox` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Fs, "fs"],
                /,
                *,
                atomic_write_dir: builtins.str = ...,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `fs` service.

                Parameters
                ----------
                atomic_write_dir : builtins.str, optional
                    tmp dir for atomic write
                root : builtins.str, optional
                    root dir for backend
                Returns
                -------
                Operator
                    The new `Operator` for `fs` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Ftp, "ftp"],
                /,
                *,
                endpoint: builtins.str = ...,
                password: builtins.str = ...,
                root: builtins.str = ...,
                user: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `ftp` service.

                Parameters
                ----------
                endpoint : builtins.str, optional
                    endpoint of this backend
                password : builtins.str, optional
                    password of this backend
                root : builtins.str, optional
                    root of this backend
                user : builtins.str, optional
                    user of this backend
                Returns
                -------
                Operator
                    The new `Operator` for `ftp` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Gcs, "gcs"],
                /,
                *,
                allow_anonymous: builtins.bool = ...,
                bucket: builtins.str,
                credential: builtins.str = ...,
                credential_path: builtins.str = ...,
                default_storage_class: builtins.str = ...,
                disable_config_load: builtins.bool = ...,
                disable_vm_metadata: builtins.bool = ...,
                endpoint: builtins.str = ...,
                predefined_acl: builtins.str = ...,
                root: builtins.str = ...,
                scope: builtins.str = ...,
                service_account: builtins.str = ...,
                skip_signature: builtins.bool = ...,
                token: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `gcs` service.

                Parameters
                ----------
                allow_anonymous : builtins.bool, optional
                    Allow opendal to send requests without signing when
                    credentials are not loaded.
                bucket : builtins.str
                    bucket name
                credential : builtins.str, optional
                    Credentials string for GCS service OAuth2
                    authentication.
                credential_path : builtins.str, optional
                    Local path to credentials file for GCS service
                    OAuth2 authentication.
                default_storage_class : builtins.str, optional
                    The default storage class used by gcs.
                disable_config_load : builtins.bool, optional
                    Disable loading configuration from the environment.
                disable_vm_metadata : builtins.bool, optional
                    Disable attempting to load credentials from the GCE
                    metadata server when running within Google Cloud.
                endpoint : builtins.str, optional
                    endpoint URI of GCS service, default is
                    `https://storage.googleapis.com`
                predefined_acl : builtins.str, optional
                    The predefined acl for GCS.
                root : builtins.str, optional
                    root URI, all operations happens under `root`
                scope : builtins.str, optional
                    Scope for gcs.
                service_account : builtins.str, optional
                    Service Account for gcs.
                skip_signature : builtins.bool, optional
                    Skip signature will skip loading credentials and
                    signing requests.
                token : builtins.str, optional
                    A Google Cloud OAuth2 token.
                    Takes precedence over `credential` and
                    `credential_path`.
                Returns
                -------
                Operator
                    The new `Operator` for `gcs` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Gdrive, "gdrive"],
                /,
                *,
                access_token: builtins.str = ...,
                client_id: builtins.str = ...,
                client_secret: builtins.str = ...,
                refresh_token: builtins.str = ...,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `gdrive` service.

                Parameters
                ----------
                access_token : builtins.str, optional
                    Access token for gdrive.
                client_id : builtins.str, optional
                    Client id for gdrive.
                client_secret : builtins.str, optional
                    Client secret for gdrive.
                refresh_token : builtins.str, optional
                    Refresh token for gdrive.
                root : builtins.str, optional
                    The root for gdrive
                Returns
                -------
                Operator
                    The new `Operator` for `gdrive` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Ghac, "ghac"],
                /,
                *,
                endpoint: builtins.str = ...,
                root: builtins.str = ...,
                runtime_token: builtins.str = ...,
                version: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `ghac` service.

                Parameters
                ----------
                endpoint : builtins.str, optional
                    The endpoint for ghac service.
                root : builtins.str, optional
                    The root path for ghac.
                runtime_token : builtins.str, optional
                    The runtime token for ghac service.
                version : builtins.str, optional
                    The version that used by cache.
                Returns
                -------
                Operator
                    The new `Operator` for `ghac` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Goosefs, "goosefs"],
                /,
                *,
                auth_type: builtins.str = ...,
                auth_username: builtins.str = ...,
                block_size: builtins.int = ...,
                chunk_size: builtins.int = ...,
                master_addr: builtins.str = ...,
                root: builtins.str = ...,
                write_type: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `goosefs` service.

                Parameters
                ----------
                auth_type : builtins.str, optional
                    Authentication type.
                    Supported values: `"nosasl"`, `"simple"`.
                    Default: `"simple"` — PLAIN SASL with usernam
                    e. `"nosasl"` — skip authentication entirely.
                auth_username : builtins.str, optional
                    Authentication username.
                    Used in SIMPLE mode as the login identity.
                    Default: current OS user (`$USER` / `$USERNAME`).
                block_size : builtins.int, optional
                    Block size in bytes for new files (default: 64 MiB).
                chunk_size : builtins.int, optional
                    Chunk size in bytes for streaming RPCs (default: 1
                    MiB).
                master_addr : builtins.str, optional
                    Master address(es) in `host:port` format.
                    For single master: `"10.0.0.1:9200"` For HA
                    (comma-separated):
                    `"10.0.0.1:9200,10.0.0.2:9200,10.0.0.3:9200"` When
                    multiple addresses are provided, the client uses
                    `PollingMasterInquireClient` to discover the Primary
                    Master automatically.
                    Resolution precedence at `build()` time (highest →
                    lowest), following `goosefs-sdk`
                    `docs/CLIENT_CONFIGURATION.md` §1:
                    1. This field (when set on the builder / OpenDAL
                    config map)
                    2. `GOOSEFS_MASTER_ADDR` environment variable
                    3. `goosefs.master.rpc.addresses` /
                    `goosefs.master.hostname` in
                    `goosefs-site.properties` `build()` fails with
                    `ConfigInvalid` only when **none** of the above
                    supplies a master address.
                root : builtins.str, optional
                    Root path of this backend.
                    All operations will happen under this root.
                    Default to `/` if not set.
                write_type : builtins.str, optional
                    Default write type for new files.
                    Supported values: `"must_cache"`, `"cache_through"`,
                    `"through"`, `"async_through"`.
                    Default: `"must_cache"`.
                Returns
                -------
                Operator
                    The new `Operator` for `goosefs` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Gridfs, "gridfs"],
                /,
                *,
                bucket: builtins.str = ...,
                chunk_size: builtins.int = ...,
                connection_string: builtins.str = ...,
                database: builtins.str = ...,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `gridfs` service.

                Parameters
                ----------
                bucket : builtins.str, optional
                    The bucket name of the MongoDB GridFs service to
                    read/write.
                chunk_size : builtins.int, optional
                    The chunk size of the MongoDB GridFs service used to
                    break the user file into chunks.
                connection_string : builtins.str, optional
                    The connection string of the MongoDB service.
                database : builtins.str, optional
                    The database name of the MongoDB GridFs service to
                    read/write.
                root : builtins.str, optional
                    The working directory, all operations will be
                    performed under it.
                Returns
                -------
                Operator
                    The new `Operator` for `gridfs` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.HdfsNative, "hdfs-native"],
                /,
                *,
                enable_append: builtins.bool = ...,
                name_node: builtins.str = ...,
                options: builtins.dict = ...,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `hdfs-native` service.

                Parameters
                ----------
                enable_append : builtins.bool, optional
                    Deprecated: HDFS Native append capability is enabled
                    by default.
                name_node : builtins.str, optional
                    name_node of this backend
                options : builtins.dict, optional
                    other options for hdfs client
                root : builtins.str, optional
                    work dir of this backend
                Returns
                -------
                Operator
                    The new `Operator` for `hdfs-native` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Hf, "hf"],
                /,
                *,
                download_mode: builtins.str = ...,
                endpoint: builtins.str = ...,
                repo_id: builtins.str = ...,
                repo_type: builtins.str = ...,
                revision: builtins.str = ...,
                root: builtins.str = ...,
                token: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `hf` service.

                Parameters
                ----------
                download_mode : builtins.str, optional
                    Download mode.
                    Either `xet` (default) or `http`.
                endpoint : builtins.str, optional
                    Endpoint of the Hugging Face Hub.
                    Default is "https://huggingface.co".
                repo_id : builtins.str, optional
                    Repo id of this backend.
                    This is required.
                repo_type : builtins.str, optional
                    Repo type of this backend.
                    Required.
                revision : builtins.str, optional
                    Revision of this backend.
                    Default is main.
                root : builtins.str, optional
                    Root of this backend.
                    Can be "/path/to/dir".
                    Default is "/".
                token : builtins.str, optional
                    Token of this backend.
                    This is optional.
                Returns
                -------
                Operator
                    The new `Operator` for `hf` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Http, "http"],
                /,
                *,
                endpoint: builtins.str = ...,
                password: builtins.str = ...,
                root: builtins.str = ...,
                token: builtins.str = ...,
                username: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `http` service.

                Parameters
                ----------
                endpoint : builtins.str, optional
                    endpoint of this backend
                password : builtins.str, optional
                    password of this backend
                root : builtins.str, optional
                    root of this backend
                token : builtins.str, optional
                    token of this backend
                username : builtins.str, optional
                    username of this backend
                Returns
                -------
                Operator
                    The new `Operator` for `http` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Ipfs, "ipfs"],
                /,
                *,
                endpoint: builtins.str = ...,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `ipfs` service.

                Parameters
                ----------
                endpoint : builtins.str, optional
                    IPFS gateway endpoint.
                root : builtins.str, optional
                    IPFS root.
                Returns
                -------
                Operator
                    The new `Operator` for `ipfs` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Ipmfs, "ipmfs"],
                /,
                *,
                endpoint: builtins.str = ...,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `ipmfs` service.

                Parameters
                ----------
                endpoint : builtins.str, optional
                    Endpoint for ipfs.
                root : builtins.str, optional
                    Root for ipfs.
                Returns
                -------
                Operator
                    The new `Operator` for `ipmfs` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Koofr, "koofr"],
                /,
                *,
                email: builtins.str,
                endpoint: builtins.str,
                password: builtins.str = ...,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `koofr` service.

                Parameters
                ----------
                email : builtins.str
                    Koofr email.
                endpoint : builtins.str
                    Koofr endpoint.
                password : builtins.str, optional
                    password of this backend.
                    (Must be the application password)
                root : builtins.str, optional
                    root of this backend.
                    All operations will happen under this root.
                Returns
                -------
                Operator
                    The new `Operator` for `koofr` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Memcached, "memcached"],
                /,
                *,
                connection_pool_max_size: builtins.int = ...,
                default_ttl: typing.Any = ...,
                endpoint: builtins.str = ...,
                password: builtins.str = ...,
                root: builtins.str = ...,
                username: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `memcached` service.

                Parameters
                ----------
                connection_pool_max_size : builtins.int, optional
                    The maximum number of connections allowed.
                    default is 10
                default_ttl : typing.Any, optional
                    The default ttl for put operations..
                    a human readable duration string see
                    https://docs.rs/humantime/latest/humantime/fn.parse_duration.html
                    for more details
                endpoint : builtins.str, optional
                    network address of the memcached service.
                    For example: "tcp://localhost:11211"
                password : builtins.str, optional
                    Memcached password, optional.
                root : builtins.str, optional
                    the working directory of the service.
                    Can be "/path/to/dir" default is "/"
                username : builtins.str, optional
                    Memcached username, optional.
                Returns
                -------
                Operator
                    The new `Operator` for `memcached` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Memory, "memory"],
                /,
                *,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `memory` service.

                Parameters
                ----------
                root : builtins.str, optional
                    root of the backend.
                Returns
                -------
                Operator
                    The new `Operator` for `memory` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.MiniMoka, "mini-moka"],
                /,
                *,
                max_capacity: builtins.int = ...,
                root: builtins.str = ...,
                time_to_idle: builtins.str = ...,
                time_to_live: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `mini-moka` service.

                Parameters
                ----------
                max_capacity : builtins.int, optional
                    Sets the max capacity of the cache.
                    Refer to
                    [`mini-moka::sync::CacheBuilder::max_capacity`](https://docs.rs/mini-moka/latest/mini_moka/sync/struct.CacheBuilder.html#method.max_capacity)
                root : builtins.str, optional
                    root path of this backend
                time_to_idle : builtins.str, optional
                    Sets the time to idle of the cache.
                    Refer to
                    [`mini-moka::sync::CacheBuilder::time_to_idle`](https://docs.rs/mini-moka/latest/mini_moka/sync/struct.CacheBuilder.html#method.time_to_idle)
                time_to_live : builtins.str, optional
                    Sets the time to live of the cache.
                    Refer to
                    [`mini-moka::sync::CacheBuilder::time_to_live`](https://docs.rs/mini-moka/latest/mini_moka/sync/struct.CacheBuilder.html#method.time_to_live)
                Returns
                -------
                Operator
                    The new `Operator` for `mini-moka` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Moka, "moka"],
                /,
                *,
                max_capacity: builtins.int = ...,
                name: builtins.str = ...,
                root: builtins.str = ...,
                time_to_idle: builtins.str = ...,
                time_to_live: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `moka` service.

                Parameters
                ----------
                max_capacity : builtins.int, optional
                    Sets the max capacity of the cache.
                    Refer to
                    [`moka::future::CacheBuilder::max_capacity`](https://docs.rs/moka/latest/moka/future/struct.CacheBuilder.html#method.max_capacity)
                name : builtins.str, optional
                    Name for this cache instance.
                root : builtins.str, optional
                    root path of this backend
                time_to_idle : builtins.str, optional
                    Sets the time to idle of the cache.
                    Refer to
                    [`moka::future::CacheBuilder::time_to_idle`](https://docs.rs/moka/latest/moka/future/struct.CacheBuilder.html#method.time_to_idle)
                time_to_live : builtins.str, optional
                    Sets the time to live of the cache.
                    Refer to
                    [`moka::future::CacheBuilder::time_to_live`](https://docs.rs/moka/latest/moka/future/struct.CacheBuilder.html#method.time_to_live)
                Returns
                -------
                Operator
                    The new `Operator` for `moka` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Mongodb, "mongodb"],
                /,
                *,
                collection: builtins.str = ...,
                connection_string: builtins.str = ...,
                database: builtins.str = ...,
                key_field: builtins.str = ...,
                root: builtins.str = ...,
                value_field: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `mongodb` service.

                Parameters
                ----------
                collection : builtins.str, optional
                    collection of this backend
                connection_string : builtins.str, optional
                    connection string of this backend
                database : builtins.str, optional
                    database of this backend
                key_field : builtins.str, optional
                    key field of this backend
                root : builtins.str, optional
                    root of this backend
                value_field : builtins.str, optional
                    value field of this backend
                Returns
                -------
                Operator
                    The new `Operator` for `mongodb` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Mysql, "mysql"],
                /,
                *,
                connection_string: builtins.str = ...,
                key_field: builtins.str = ...,
                root: builtins.str = ...,
                table: builtins.str = ...,
                value_field: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `mysql` service.

                Parameters
                ----------
                connection_string : builtins.str, optional
                    This connection string is used to connect to the
                    mysql service.
                    There are url based formats.
                    The format of connect string resembles the url
                    format of the mysql client.
                    The format is:
                    `[scheme://][user[:[password]]@]host[:port][/schema][?attribute1=value1&attribute2=value2...`
                    - `mysql://user@localhost` -
                    `mysql://user:password@localhost` -
                    `mysql://user:password@localhost:3306` -
                    `mysql://user:password@localhost:3306/db` For more
                    information, please refer to
                    <https://docs.rs/sqlx/latest/sqlx/mysql/struct.MySqlConnectOptions.html>.
                key_field : builtins.str, optional
                    The key field name for mysql.
                root : builtins.str, optional
                    The root for mysql.
                table : builtins.str, optional
                    The table name for mysql.
                value_field : builtins.str, optional
                    The value field name for mysql.
                Returns
                -------
                Operator
                    The new `Operator` for `mysql` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Obs, "obs"],
                /,
                *,
                access_key_id: builtins.str = ...,
                bucket: builtins.str = ...,
                enable_versioning: builtins.bool = ...,
                endpoint: builtins.str = ...,
                root: builtins.str = ...,
                secret_access_key: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `obs` service.

                Parameters
                ----------
                access_key_id : builtins.str, optional
                    Access key id for obs.
                bucket : builtins.str, optional
                    Bucket for obs.
                enable_versioning : builtins.bool, optional
                    Deprecated: OBS versioning capability is not
                    controlled by service config.
                endpoint : builtins.str, optional
                    Endpoint for obs.
                root : builtins.str, optional
                    Root for obs.
                secret_access_key : builtins.str, optional
                    Secret access key for obs.
                Returns
                -------
                Operator
                    The new `Operator` for `obs` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Onedrive, "onedrive"],
                /,
                *,
                access_token: builtins.str = ...,
                client_id: builtins.str = ...,
                client_secret: builtins.str = ...,
                enable_versioning: builtins.bool = ...,
                refresh_token: builtins.str = ...,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `onedrive` service.

                Parameters
                ----------
                access_token : builtins.str, optional
                    Microsoft Graph API (also OneDrive API) access token
                client_id : builtins.str, optional
                    Microsoft Graph API Application (client) ID that is
                    in the Azure's app registration portal
                client_secret : builtins.str, optional
                    Microsoft Graph API Application client secret that
                    is in the Azure's app registration portal
                enable_versioning : builtins.bool, optional
                    Deprecated: OneDrive versioning capability is
                    enabled by default.
                refresh_token : builtins.str, optional
                    Microsoft Graph API (also OneDrive API) refresh
                    token
                root : builtins.str, optional
                    The root path for the OneDrive service for the file
                    access
                Returns
                -------
                Operator
                    The new `Operator` for `onedrive` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Oss, "oss"],
                /,
                *,
                access_key_id: builtins.str = ...,
                access_key_secret: builtins.str = ...,
                addressing_style: builtins.str = ...,
                allow_anonymous: builtins.bool = ...,
                batch_max_operations: builtins.int = ...,
                bucket: builtins.str,
                delete_max_size: builtins.int = ...,
                enable_versioning: builtins.bool = ...,
                endpoint: builtins.str = ...,
                external_id: builtins.str = ...,
                oidc_provider_arn: builtins.str = ...,
                oidc_token_file: builtins.str = ...,
                presign_addressing_style: builtins.str = ...,
                presign_endpoint: builtins.str = ...,
                role_arn: builtins.str = ...,
                role_session_name: builtins.str = ...,
                root: builtins.str = ...,
                security_token: builtins.str = ...,
                server_side_encryption: builtins.str = ...,
                server_side_encryption_key_id: builtins.str = ...,
                skip_signature: builtins.bool = ...,
                sts_endpoint: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `oss` service.

                Parameters
                ----------
                access_key_id : builtins.str, optional
                    Access key id for oss.
                    - this field if it's `is_some` - env value:
                    `ALIBABA_CLOUD_ACCESS_KEY_ID`
                access_key_secret : builtins.str, optional
                    Access key secret for oss.
                    - this field if it's `is_some` - env value:
                    `ALIBABA_CLOUD_ACCESS_KEY_SECRET`
                addressing_style : builtins.str, optional
                    Addressing style for oss.
                allow_anonymous : builtins.bool, optional
                    Allow anonymous for oss.
                batch_max_operations : builtins.int, optional
                    Deprecated: OSS delete batch capability is enabled
                    by default.
                bucket : builtins.str
                    Bucket for oss.
                delete_max_size : builtins.int, optional
                    Deprecated: OSS delete batch capability is enabled
                    by default.
                enable_versioning : builtins.bool, optional
                    Deprecated: OSS versioning capability is enabled by
                    default.
                endpoint : builtins.str, optional
                    Endpoint for oss.
                external_id : builtins.str, optional
                    external_id for this backend.
                oidc_provider_arn : builtins.str, optional
                    `oidc_provider_arn` will be loaded from - this field
                    if it's `is_some` - env value:
                    `ALIBABA_CLOUD_OIDC_PROVIDER_ARN`
                oidc_token_file : builtins.str, optional
                    `oidc_token_file` will be loaded from - this field
                    if it's `is_some` - env value:
                    `ALIBABA_CLOUD_OIDC_TOKEN_FILE`
                presign_addressing_style : builtins.str, optional
                    Pre sign addressing style for oss.
                presign_endpoint : builtins.str, optional
                    Presign endpoint for oss.
                role_arn : builtins.str, optional
                    If `role_arn` is set, we will use already known
                    config as source credential to assume role with
                    `role_arn`.
                    - this field if it's `is_some` - env value:
                    `ALIBABA_CLOUD_ROLE_ARN`
                role_session_name : builtins.str, optional
                    role_session_name for this backend.
                root : builtins.str, optional
                    Root for oss.
                security_token : builtins.str, optional
                    `security_token` will be loaded from - this field if
                    it's `is_some` - env value:
                    `ALIBABA_CLOUD_SECURITY_TOKEN`
                server_side_encryption : builtins.str, optional
                    Server side encryption for oss.
                server_side_encryption_key_id : builtins.str, optional
                    Server side encryption key id for oss.
                skip_signature : builtins.bool, optional
                    Skip signature will skip loading credentials and
                    signing requests.
                sts_endpoint : builtins.str, optional
                    `sts_endpoint` will be loaded from - this field if
                    it's `is_some` - env value:
                    `ALIBABA_CLOUD_STS_ENDPOINT`
                Returns
                -------
                Operator
                    The new `Operator` for `oss` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Persy, "persy"],
                /,
                *,
                datafile: builtins.str = ...,
                index: builtins.str = ...,
                segment: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `persy` service.

                Parameters
                ----------
                datafile : builtins.str, optional
                    That path to the persy data file.
                    The directory in the path must already exist.
                index : builtins.str, optional
                    That name of the persy index.
                segment : builtins.str, optional
                    That name of the persy segment.
                Returns
                -------
                Operator
                    The new `Operator` for `persy` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Postgresql, "postgresql"],
                /,
                *,
                connection_string: builtins.str = ...,
                key_field: builtins.str = ...,
                root: builtins.str = ...,
                table: builtins.str = ...,
                value_field: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `postgresql` service.

                Parameters
                ----------
                connection_string : builtins.str, optional
                    The URL should be with a scheme of either
                    `postgres://` or `postgresql://`.
                    - `postgresql://user@localhost` -
                    `postgresql://user:password@%2Fvar%2Flib%2Fpostgresql/mydb?connect_timeout=10`
                    -
                    `postgresql://user@host1:1234,host2,host3:5678?target_session_attrs=read-write`
                    -
                    `postgresql:///mydb?user=user&host=/var/lib/postgresql`
                    For more information, please visit
                    <https://docs.rs/sqlx/latest/sqlx/postgres/struct.PgConnectOptions.html>.
                key_field : builtins.str, optional
                    the key field of postgresql
                root : builtins.str, optional
                    Root of this backend.
                    All operations will happen under this root.
                    Default to `/` if not set.
                table : builtins.str, optional
                    the table of postgresql
                value_field : builtins.str, optional
                    the value field of postgresql
                Returns
                -------
                Operator
                    The new `Operator` for `postgresql` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Redb, "redb"],
                /,
                *,
                datadir: builtins.str = ...,
                root: builtins.str = ...,
                table: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `redb` service.

                Parameters
                ----------
                datadir : builtins.str, optional
                    path to the redb data directory.
                root : builtins.str, optional
                    The root for redb.
                table : builtins.str, optional
                    The table name for redb.
                Returns
                -------
                Operator
                    The new `Operator` for `redb` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Redis, "redis"],
                /,
                *,
                cluster_endpoints: builtins.str = ...,
                connection_pool_max_size: builtins.int = ...,
                db: builtins.int,
                default_ttl: typing.Any = ...,
                endpoint: builtins.str = ...,
                password: builtins.str = ...,
                root: builtins.str = ...,
                username: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `redis` service.

                Parameters
                ----------
                cluster_endpoints : builtins.str, optional
                    network address of the Redis cluster service.
                    Can be
                    "tcp://127.0.0.1:6379,tcp://127.0.0.1:6380,tcp://127.0.0.1:6381",
                    e.g.
                    default is None
                connection_pool_max_size : builtins.int, optional
                    The maximum number of connections allowed.
                    default is 10
                db : builtins.int
                    the number of DBs redis can take is unlimited
                    default is db 0
                default_ttl : typing.Any, optional
                    The default ttl for put operations..
                    a human readable duration string see
                    https://docs.rs/humantime/latest/humantime/fn.parse_duration.html
                    for more details
                endpoint : builtins.str, optional
                    network address of the Redis service.
                    Can be "tcp://127.0.0.1:6379", e.g.
                    default is "tcp://127.0.0.1:6379"
                password : builtins.str, optional
                    the password for authentication default is None
                root : builtins.str, optional
                    the working directory of the Redis service.
                    Can be "/path/to/dir" default is "/"
                username : builtins.str, optional
                    the username to connect redis service.
                    default is None
                Returns
                -------
                Operator
                    The new `Operator` for `redis` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.S3, "s3"],
                /,
                *,
                access_key_id: builtins.str = ...,
                allow_anonymous: builtins.bool = ...,
                assume_role_duration_seconds: builtins.int = ...,
                assume_role_session_tags: builtins.dict = ...,
                batch_max_operations: builtins.int = ...,
                bucket: builtins.str,
                checksum_algorithm: builtins.str = ...,
                default_acl: builtins.str = ...,
                default_storage_class: builtins.str = ...,
                delete_max_size: builtins.int = ...,
                disable_config_load: builtins.bool = ...,
                disable_ec2_metadata: builtins.bool = ...,
                disable_list_objects_v2: builtins.bool = ...,
                disable_stat_with_override: builtins.bool = ...,
                disable_write_with_if_match: builtins.bool = ...,
                enable_request_payer: builtins.bool = ...,
                enable_versioning: builtins.bool = ...,
                enable_virtual_host_style: builtins.bool = ...,
                enable_write_with_append: builtins.bool = ...,
                endpoint: builtins.str = ...,
                external_id: builtins.str = ...,
                region: builtins.str = ...,
                role_arn: builtins.str = ...,
                role_session_name: builtins.str = ...,
                root: builtins.str = ...,
                secret_access_key: builtins.str = ...,
                server_side_encryption: builtins.str = ...,
                server_side_encryption_aws_kms_key_id: builtins.str = ...,
                server_side_encryption_customer_algorithm: builtins.str = ...,
                server_side_encryption_customer_key: builtins.str = ...,
                server_side_encryption_customer_key_md5: builtins.str = ...,
                session_token: builtins.str = ...,
                skip_signature: builtins.bool = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `s3` service.

                Parameters
                ----------
                access_key_id : builtins.str, optional
                    access_key_id of this backend.
                    - If access_key_id is set, we will take user's input
                    first.
                    - If not, we will try to load it from environment.
                allow_anonymous : builtins.bool, optional
                    Allow anonymous will allow opendal to send request
                    without signing when credential is not loaded.
                assume_role_duration_seconds : builtins.int, optional
                    assume_role_duration_seconds for this backend.
                assume_role_session_tags : builtins.dict, optional
                    assume_role_session_tags for this backend.
                batch_max_operations : builtins.int, optional
                    Deprecated: S3 delete batch capability is enabled by
                    default.
                bucket : builtins.str
                    bucket name of this backend.
                    required.
                checksum_algorithm : builtins.str, optional
                    Checksum Algorithm to use when sending checksums in
                    HTTP headers.
                    This is necessary when writing to AWS S3 Buckets
                    with Object Lock enabled for example.
                    Available options: - "crc32c" - "md5"
                default_acl : builtins.str, optional
                    Default ACL for new objects.
                    Note that some s3 services like minio do not support
                    this option.
                default_storage_class : builtins.str, optional
                    default storage_class for this backend.
                    Available values: - `DEEP_ARCHIVE` - `GLACIER` -
                    `GLACIER_IR` - `INTELLIGENT_TIERING` - `ONEZONE_IA`
                    - `EXPRESS_ONEZONE` - `OUTPOSTS` -
                    `REDUCED_REDUNDANCY` - `STANDARD` - `STANDARD_IA` S3
                    compatible services don't support all of them
                delete_max_size : builtins.int, optional
                    Deprecated: S3 delete batch capability is enabled by
                    default.
                disable_config_load : builtins.bool, optional
                    Disable config load so that opendal will not load
                    config from environment.
                    For examples: - envs like `AWS_ACCESS_KEY_ID` -
                    files like `~/.aws/config`
                disable_ec2_metadata : builtins.bool, optional
                    Disable load credential from ec2 metadata.
                    This option is used to disable the default behavior
                    of opendal to load credential from ec2 metadata,
                    a.k.a., IMDSv2
                disable_list_objects_v2 : builtins.bool, optional
                    OpenDAL uses List Objects V2 by default to list
                    objects.
                    However, some legacy services do not yet support V2.
                    This option allows users to switch back to the older
                    List Objects V1.
                disable_stat_with_override : builtins.bool, optional
                    Deprecated: S3 stat override capabilities are
                    enabled by default.
                disable_write_with_if_match : builtins.bool, optional
                    Deprecated: S3 write with If-Match capability is
                    enabled by default.
                enable_request_payer : builtins.bool, optional
                    Indicates whether the client agrees to pay for the
                    requests made to the S3 bucket.
                enable_versioning : builtins.bool, optional
                    Deprecated: S3 versioning capability is enabled by
                    default.
                enable_virtual_host_style : builtins.bool, optional
                    Enable virtual host style so that opendal will send
                    API requests in virtual host style instead of path
                    style.
                    - By default, opendal will send API to
                    `https://s3.us-east-1.amazonaws.com/bucket_name` -
                    Enabled, opendal will send API to
                    `https://bucket_name.s3.us-east-1.amazonaws.com`
                enable_write_with_append : builtins.bool, optional
                    Deprecated: S3 append capability is enabled by
                    default.
                endpoint : builtins.str, optional
                    endpoint of this backend.
                    Endpoint must be full uri, e.g.
                    - AWS S3: `https://s3.amazonaws.com` or
                    `https://s3.{region}.amazonaws.com` - Cloudflare R2:
                    `https://<ACCOUNT_ID>.r2.cloudflarestorage.com` -
                    Aliyun OSS: `https://{region}.aliyuncs.com` -
                    Tencent COS: `https://cos.{region}.myqcloud.com` -
                    Minio: `http://127.0.0.1:9000` If user inputs
                    endpoint without scheme like "s3.amazonaws.com", we
                    will prepend "https://" before it.
                    - If endpoint is set, we will take user's input
                    first.
                    - If not, we will try to load it from environment.
                    - If still not set, default to
                    `https://s3.amazonaws.com`.
                external_id : builtins.str, optional
                    external_id for this backend.
                region : builtins.str, optional
                    Region represent the signing region of this
                    endpoint.
                    This is required if you are using the default AWS S3
                    endpoint.
                    If using a custom endpoint, - If region is set, we
                    will take user's input first.
                    - If not, we will try to load it from environment.
                role_arn : builtins.str, optional
                    role_arn for this backend.
                    If `role_arn` is set, we will use already known
                    config as source credential to assume role with
                    `role_arn`.
                role_session_name : builtins.str, optional
                    role_session_name for this backend.
                root : builtins.str, optional
                    root of this backend.
                    All operations will happen under this root.
                    default to `/` if not set.
                secret_access_key : builtins.str, optional
                    secret_access_key of this backend.
                    - If secret_access_key is set, we will take user's
                    input first.
                    - If not, we will try to load it from environment.
                server_side_encryption : builtins.str, optional
                    server_side_encryption for this backend.
                    Available values: `AES256`, `aws:kms`.
                server_side_encryption_aws_kms_key_id : builtins.str, optional
                    server_side_encryption_aws_kms_key_id for this
                    backend - If `server_side_encryption` set to
                    `aws:kms`, and
                    `server_side_encryption_aws_kms_key_id` is not set,
                    S3 will use aws managed kms key to encrypt data.
                    - If `server_side_encryption` set to `aws:kms`, and
                    `server_side_encryption_aws_kms_key_id` is a valid
                    kms key id, S3 will use the provided kms key to
                    encrypt data.
                    - If the `server_side_encryption_aws_kms_key_id` is
                    invalid or not found, an error will be returned.
                    - If `server_side_encryption` is not `aws:kms`,
                    setting `server_side_encryption_aws_kms_key_id` is a
                    noop.
                server_side_encryption_customer_algorithm : builtins.str, optional
                    server_side_encryption_customer_algorithm for this
                    backend.
                    Available values: `AES256`.
                server_side_encryption_customer_key : builtins.str, optional
                    server_side_encryption_customer_key for this
                    backend.
                    Value: BASE64-encoded key that matches algorithm
                    specified in
                    `server_side_encryption_customer_algorithm`.
                server_side_encryption_customer_key_md5 : builtins.str, optional
                    Set server_side_encryption_customer_key_md5 for this
                    backend.
                    Value: MD5 digest of key specified in
                    `server_side_encryption_customer_key`.
                session_token : builtins.str, optional
                    session_token (aka, security token) of this backend.
                    This token will expire after sometime, it's
                    recommended to set session_token by hand.
                skip_signature : builtins.bool, optional
                    Skip signature will skip loading credentials and
                    signing requests.
                Returns
                -------
                Operator
                    The new `Operator` for `s3` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Seafile, "seafile"],
                /,
                *,
                endpoint: builtins.str = ...,
                password: builtins.str = ...,
                repo_name: builtins.str,
                root: builtins.str = ...,
                username: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `seafile` service.

                Parameters
                ----------
                endpoint : builtins.str, optional
                    endpoint address of this backend.
                password : builtins.str, optional
                    password of this backend.
                repo_name : builtins.str
                    repo_name of this backend.
                    required.
                root : builtins.str, optional
                    root of this backend.
                    All operations will happen under this root.
                username : builtins.str, optional
                    username of this backend.
                Returns
                -------
                Operator
                    The new `Operator` for `seafile` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Sftp, "sftp"],
                /,
                *,
                enable_copy: builtins.bool = ...,
                endpoint: builtins.str = ...,
                key: builtins.str = ...,
                known_hosts_strategy: builtins.str = ...,
                root: builtins.str = ...,
                user: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `sftp` service.

                Parameters
                ----------
                enable_copy : builtins.bool, optional
                    Deprecated: SFTP copy capability is enabled by
                    default.
                endpoint : builtins.str, optional
                    endpoint of this backend
                key : builtins.str, optional
                    key of this backend
                known_hosts_strategy : builtins.str, optional
                    known_hosts_strategy of this backend
                root : builtins.str, optional
                    root of this backend
                user : builtins.str, optional
                    user of this backend
                Returns
                -------
                Operator
                    The new `Operator` for `sftp` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Sled, "sled"],
                /,
                *,
                datadir: builtins.str = ...,
                root: builtins.str = ...,
                tree: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `sled` service.

                Parameters
                ----------
                datadir : builtins.str, optional
                    That path to the sled data directory.
                root : builtins.str, optional
                    The root for sled.
                tree : builtins.str, optional
                    The tree for sled.
                Returns
                -------
                Operator
                    The new `Operator` for `sled` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Sqlite, "sqlite"],
                /,
                *,
                connection_string: builtins.str = ...,
                key_field: builtins.str = ...,
                root: builtins.str = ...,
                table: builtins.str = ...,
                value_field: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `sqlite` service.

                Parameters
                ----------
                connection_string : builtins.str, optional
                    Set the connection_string of the sqlite service.
                    This connection string is used to connect to the
                    sqlite service.
                    The format of connect string resembles the url
                    format of the sqlite client: - `sqlite::memory:` -
                    `sqlite:data.db` - `sqlite://data.db` For more
                    information, please visit
                    <https://docs.rs/sqlx/latest/sqlx/sqlite/struct.SqliteConnectOptions.html>.
                key_field : builtins.str, optional
                    Set the key field name of the sqlite service to
                    read/write.
                    Default to `key` if not specified.
                root : builtins.str, optional
                    set the working directory, all operations will be
                    performed under it.
                    default: "/"
                table : builtins.str, optional
                    Set the table name of the sqlite service to
                    read/write.
                value_field : builtins.str, optional
                    Set the value field name of the sqlite service to
                    read/write.
                    Default to `value` if not specified.
                Returns
                -------
                Operator
                    The new `Operator` for `sqlite` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Swift, "swift"],
                /,
                *,
                container: builtins.str = ...,
                endpoint: builtins.str = ...,
                root: builtins.str = ...,
                temp_url_hash_algorithm: builtins.str = ...,
                temp_url_key: builtins.str = ...,
                token: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `swift` service.

                Parameters
                ----------
                container : builtins.str, optional
                    The container for Swift.
                endpoint : builtins.str, optional
                    The endpoint for Swift.
                root : builtins.str, optional
                    The root for Swift.
                temp_url_hash_algorithm : builtins.str, optional
                    The hash algorithm for TempURL signing.
                    Supported values: `sha1`, `sha256`, `sha512`.
                    Defaults to `sha256`.
                    The cluster must have the chosen algorithm in its
                    `tempurl.allowed_digests` (check `GET /info`).
                temp_url_key : builtins.str, optional
                    The TempURL key for generating presigned URLs.
                    This corresponds to the
                    `X-Account-Meta-Temp-URL-Key` or
                    `X-Container-Meta-Temp-URL-Key` header value
                    configured on the Swift account or container.
                token : builtins.str, optional
                    The token for Swift.
                Returns
                -------
                Operator
                    The new `Operator` for `swift` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Tos, "tos"],
                /,
                *,
                access_key_id: builtins.str = ...,
                bucket: builtins.str,
                disable_config_load: builtins.bool = ...,
                endpoint: builtins.str = ...,
                region: builtins.str = ...,
                root: builtins.str = ...,
                secret_access_key: builtins.str = ...,
                security_token: builtins.str = ...,
                skip_signature: builtins.bool = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `tos` service.

                Parameters
                ----------
                access_key_id : builtins.str, optional
                    access_key_id of this backend.
                    - If access_key_id is set, we will take user's input
                    first.
                    - If not, we will try to load it from environment.
                bucket : builtins.str
                    bucket name of this backend.
                    required.
                disable_config_load : builtins.bool, optional
                    Disable config load so that opendal will not load
                    config from environment.
                    For examples: - envs like `TOS_ACCESS_KEY_ID`
                endpoint : builtins.str, optional
                    endpoint of this backend.
                    Endpoint must be full uri, e.g.
                    - TOS: `https://tos-cn-beijing.volces.com` - TOS
                    with region: `https://tos-{region}.volces.com` If
                    user inputs endpoint without scheme like
                    "tos-cn-beijing.volces.com", we will prepend
                    "https://" before it.
                region : builtins.str, optional
                    Region represent the signing region of this
                    endpoint.
                    Required if endpoint is not provided.
                    - If region is set, we will take user's input first.
                    - If not, we will try to load it from environment.
                    - If still not set, default to `cn-beijing`.
                root : builtins.str, optional
                    root of this backend.
                    All operations will happen under this root.
                    default to `/` if not set.
                secret_access_key : builtins.str, optional
                    secret_access_key of this backend.
                    - If secret_access_key is set, we will take user's
                    input first.
                    - If not, we will try to load it from environment.
                security_token : builtins.str, optional
                    security_token of this backend.
                    This token will expire after sometime, it's
                    recommended to set security_token by hand.
                skip_signature : builtins.bool, optional
                    Skip signature will skip loading credentials and
                    signing requests.
                Returns
                -------
                Operator
                    The new `Operator` for `tos` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Upyun, "upyun"],
                /,
                *,
                bucket: builtins.str,
                operator: builtins.str = ...,
                password: builtins.str = ...,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `upyun` service.

                Parameters
                ----------
                bucket : builtins.str
                    bucket address of this backend.
                operator : builtins.str, optional
                    username of this backend.
                password : builtins.str, optional
                    password of this backend.
                root : builtins.str, optional
                    root of this backend.
                    All operations will happen under this root.
                Returns
                -------
                Operator
                    The new `Operator` for `upyun` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.VercelArtifacts, "vercel-artifacts"],
                /,
                *,
                access_token: builtins.str = ...,
                endpoint: builtins.str = ...,
                team_id: builtins.str = ...,
                team_slug: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `vercel-artifacts` service.

                Parameters
                ----------
                access_token : builtins.str, optional
                    The access token for Vercel.
                endpoint : builtins.str, optional
                    The endpoint for the Vercel artifacts API.
                    Defaults to `https://api.vercel.com`.
                team_id : builtins.str, optional
                    The Vercel team ID.
                    When set, the `teamId` query parameter is appended
                    to all API requests.
                team_slug : builtins.str, optional
                    The Vercel team slug.
                    When set, the `slug` query parameter is appended to
                    all API requests.
                Returns
                -------
                Operator
                    The new `Operator` for `vercel-artifacts` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.VercelBlob, "vercel-blob"],
                /,
                *,
                root: builtins.str = ...,
                token: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `vercel-blob` service.

                Parameters
                ----------
                root : builtins.str, optional
                    root of this backend.
                    All operations will happen under this root.
                token : builtins.str, optional
                    vercel blob token.
                Returns
                -------
                Operator
                    The new `Operator` for `vercel-blob` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Webdav, "webdav"],
                /,
                *,
                disable_copy: builtins.bool = ...,
                disable_create_dir: builtins.bool = ...,
                enable_user_metadata: builtins.bool = ...,
                endpoint: builtins.str = ...,
                password: builtins.str = ...,
                root: builtins.str = ...,
                token: builtins.str = ...,
                user_metadata_prefix: builtins.str = ...,
                user_metadata_uri: builtins.str = ...,
                username: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `webdav` service.

                Parameters
                ----------
                disable_copy : builtins.bool, optional
                    Deprecated: WebDAV copy capability is enabled by
                    default.
                disable_create_dir : builtins.bool, optional
                    Disable automatic parent directory creation before
                    write operations.
                    By default, OpenDAL creates parent directories using
                    MKCOL before writing files.
                    This requires PROPFIND support to check directory
                    existence.
                    Some WebDAV-compatible servers (e.g., bazel-remote)
                    don't support PROPFIND or don't require explicit
                    directory creation.
                    Enable this option to skip the MKCOL calls and write
                    files directly.
                    Default: false
                enable_user_metadata : builtins.bool, optional
                    Deprecated: WebDAV user metadata capability is
                    enabled by default.
                endpoint : builtins.str, optional
                    endpoint of this backend
                password : builtins.str, optional
                    password of this backend
                root : builtins.str, optional
                    root of this backend
                token : builtins.str, optional
                    token of this backend
                user_metadata_prefix : builtins.str, optional
                    The XML namespace prefix for user metadata
                    properties.
                    This prefix is used in PROPPATCH/PROPFIND XML
                    requests.
                    Different servers may require different prefixes.
                    Default: "opendal"
                user_metadata_uri : builtins.str, optional
                    The XML namespace URI for user metadata properties.
                    This URI uniquely identifies the namespace for
                    custom properties.
                    Different servers may require different namespace
                    URIs.
                    For example, Nextcloud might work better with its
                    own namespace.
                    Default: `https://opendal.apache.org/ns`
                username : builtins.str, optional
                    username of this backend
                Returns
                -------
                Operator
                    The new `Operator` for `webdav` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Webhdfs, "webhdfs"],
                /,
                *,
                atomic_write_dir: builtins.str = ...,
                delegation: builtins.str = ...,
                disable_list_batch: builtins.bool = ...,
                endpoint: builtins.str = ...,
                root: builtins.str = ...,
                user_name: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `webhdfs` service.

                Parameters
                ----------
                atomic_write_dir : builtins.str, optional
                    atomic_write_dir of this backend
                delegation : builtins.str, optional
                    Delegation token for webhdfs.
                disable_list_batch : builtins.bool, optional
                    Disable batch listing
                endpoint : builtins.str, optional
                    Endpoint for webhdfs.
                root : builtins.str, optional
                    Root for webhdfs.
                user_name : builtins.str, optional
                    Name of the user for webhdfs.
                Returns
                -------
                Operator
                    The new `Operator` for `webhdfs` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class Operator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.YandexDisk, "yandex-disk"],
                /,
                *,
                access_token: builtins.str,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `Operator` for `yandex-disk` service.

                Parameters
                ----------
                access_token : builtins.str
                    yandex disk oauth access_token.
                root : builtins.str, optional
                    root of this backend.
                    All operations will happen under this root.
                Returns
                -------
                Operator
                    The new `Operator` for `yandex-disk` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: builtins.str,
                /,
                **kwargs: builtins.str,
            ) -> typing.Self: ...
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.AliyunDrive, "aliyun-drive"],
                /,
                *,
                access_token: builtins.str = ...,
                client_id: builtins.str = ...,
                client_secret: builtins.str = ...,
                drive_type: builtins.str,
                refresh_token: builtins.str = ...,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `aliyun-drive` service.

                Parameters
                ----------
                access_token : builtins.str, optional
                    The access_token of this backend.
                    Solution for client-only purpose.
                    #4733 Required if no client_id, client_secret and
                    refresh_token are provided.
                client_id : builtins.str, optional
                    The client_id of this backend.
                    Required if no access_token is provided.
                client_secret : builtins.str, optional
                    The client_secret of this backend.
                    Required if no access_token is provided.
                drive_type : builtins.str
                    The drive_type of this backend.
                    All operations will happen under this type of drive.
                    Available values are `default`, `backup` and
                    `resource`.
                    Fallback to default if not set or no other drives
                    can be found.
                refresh_token : builtins.str, optional
                    The refresh_token of this backend.
                    Required if no access_token is provided.
                root : builtins.str, optional
                    The Root of this backend.
                    All operations will happen under this root.
                    Default to `/` if not set.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `aliyun-drive` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Alluxio, "alluxio"],
                /,
                *,
                endpoint: builtins.str = ...,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `alluxio` service.

                Parameters
                ----------
                endpoint : builtins.str, optional
                    endpoint of this backend.
                    Endpoint must be full uri, mostly like
                    `http://127.0.0.1:39999`.
                root : builtins.str, optional
                    root of this backend.
                    All operations will happen under this root.
                    default to `/` if not set.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `alluxio` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Azblob, "azblob"],
                /,
                *,
                account_key: builtins.str = ...,
                account_name: builtins.str = ...,
                batch_max_operations: builtins.int = ...,
                container: builtins.str,
                encryption_algorithm: builtins.str = ...,
                encryption_key: builtins.str = ...,
                encryption_key_sha256: builtins.str = ...,
                endpoint: builtins.str = ...,
                root: builtins.str = ...,
                sas_token: builtins.str = ...,
                skip_signature: builtins.bool = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `azblob` service.

                Parameters
                ----------
                account_key : builtins.str, optional
                    The account key of Azblob service backend.
                account_name : builtins.str, optional
                    The account name of Azblob service backend.
                batch_max_operations : builtins.int, optional
                    Deprecated: Azblob delete batch capability is
                    enabled by default with Azure Blob's 256-operation
                    batch limit.
                container : builtins.str
                    The container name of Azblob service backend.
                encryption_algorithm : builtins.str, optional
                    The encryption algorithm of Azblob service backend.
                encryption_key : builtins.str, optional
                    The encryption key of Azblob service backend.
                encryption_key_sha256 : builtins.str, optional
                    The encryption key sha256 of Azblob service backend.
                endpoint : builtins.str, optional
                    The endpoint of Azblob service backend.
                    Endpoint must be full uri, e.g.
                    - Azblob:
                    `https://accountname.blob.core.windows.net` -
                    Azurite: `http://127.0.0.1:10000/devstoreaccount1`
                root : builtins.str, optional
                    The root of Azblob service backend.
                    All operations will happen under this root.
                sas_token : builtins.str, optional
                    The sas token of Azblob service backend.
                skip_signature : builtins.bool, optional
                    Skip signature will skip loading credentials and
                    signing requests.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `azblob` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Azdls, "azdls"],
                /,
                *,
                account_key: builtins.str = ...,
                account_name: builtins.str = ...,
                authority_host: builtins.str = ...,
                client_id: builtins.str = ...,
                client_secret: builtins.str = ...,
                enable_hns: builtins.bool = ...,
                endpoint: builtins.str = ...,
                filesystem: builtins.str,
                root: builtins.str = ...,
                sas_token: builtins.str = ...,
                tenant_id: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `azdls` service.

                Parameters
                ----------
                account_key : builtins.str, optional
                    Account key of this backend.
                    - required for shared_key authentication
                account_name : builtins.str, optional
                    Account name of this backend.
                authority_host : builtins.str, optional
                    authority_host The authority host of the service
                    principal.
                    - required for client_credentials authentication -
                    default value: `https://login.microsoftonline.com`
                client_id : builtins.str, optional
                    client_id The client id of the service principal.
                    - required for client_credentials authentication
                client_secret : builtins.str, optional
                    client_secret The client secret of the service
                    principal.
                    - required for client_credentials authentication
                enable_hns : builtins.bool, optional
                    Whether hierarchical namespace (HNS) is enabled for
                    the storage account.
                    When enabled, recursive deletion can use pagination
                    to avoid timeouts on large directories.
                    - default value: `false`
                endpoint : builtins.str, optional
                    Endpoint of this backend.
                filesystem : builtins.str
                    Filesystem name of this backend.
                root : builtins.str, optional
                    Root of this backend.
                sas_token : builtins.str, optional
                    sas_token The shared access signature token.
                    - required for sas authentication
                tenant_id : builtins.str, optional
                    tenant_id The tenant id of the service principal.
                    - required for client_credentials authentication
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `azdls` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Azfile, "azfile"],
                /,
                *,
                account_key: builtins.str = ...,
                account_name: builtins.str = ...,
                endpoint: builtins.str = ...,
                root: builtins.str = ...,
                sas_token: builtins.str = ...,
                share_name: builtins.str,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `azfile` service.

                Parameters
                ----------
                account_key : builtins.str, optional
                    The account key for azfile.
                account_name : builtins.str, optional
                    The account name for azfile.
                endpoint : builtins.str, optional
                    The endpoint for azfile.
                root : builtins.str, optional
                    The root path for azfile.
                sas_token : builtins.str, optional
                    The sas token for azfile.
                share_name : builtins.str
                    The share name for azfile.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `azfile` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.B2, "b2"],
                /,
                *,
                application_key: builtins.str = ...,
                application_key_id: builtins.str = ...,
                bucket: builtins.str,
                bucket_id: builtins.str,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `b2` service.

                Parameters
                ----------
                application_key : builtins.str, optional
                    applicationKey of this backend.
                    - If application_key is set, we will take user's
                    input first.
                    - If not, we will try to load it from environment.
                application_key_id : builtins.str, optional
                    keyID of this backend.
                    - If application_key_id is set, we will take user's
                    input first.
                    - If not, we will try to load it from environment.
                bucket : builtins.str
                    bucket of this backend.
                    required.
                bucket_id : builtins.str
                    bucket id of this backend.
                    required.
                root : builtins.str, optional
                    root of this backend.
                    All operations will happen under this root.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `b2` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Cacache, "cacache"],
                /,
                *,
                datadir: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `cacache` service.

                Parameters
                ----------
                datadir : builtins.str, optional
                    That path to the cacache data directory.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `cacache` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.CloudflareKv, "cloudflare-kv"],
                /,
                *,
                account_id: builtins.str = ...,
                api_token: builtins.str = ...,
                default_ttl: typing.Any = ...,
                namespace_id: builtins.str = ...,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `cloudflare-kv` service.

                Parameters
                ----------
                account_id : builtins.str, optional
                    The account ID used to authenticate with CloudFlare.
                    Used as URI path parameter.
                api_token : builtins.str, optional
                    The token used to authenticate with CloudFlare.
                default_ttl : typing.Any, optional
                    The default ttl for write operations..
                    a human readable duration string see
                    https://docs.rs/humantime/latest/humantime/fn.parse_duration.html
                    for more details
                namespace_id : builtins.str, optional
                    The namespace ID.
                    Used as URI path parameter.
                root : builtins.str, optional
                    Root within this backend.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `cloudflare-kv` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Cos, "cos"],
                /,
                *,
                bucket: builtins.str = ...,
                disable_config_load: builtins.bool = ...,
                enable_versioning: builtins.bool = ...,
                endpoint: builtins.str = ...,
                root: builtins.str = ...,
                secret_id: builtins.str = ...,
                secret_key: builtins.str = ...,
                security_token: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `cos` service.

                Parameters
                ----------
                bucket : builtins.str, optional
                    Bucket of this backend.
                disable_config_load : builtins.bool, optional
                    Disable config load so that opendal will not load
                    config from
                enable_versioning : builtins.bool, optional
                    Deprecated: COS versioning capability is enabled by
                    default.
                endpoint : builtins.str, optional
                    Endpoint of this backend.
                root : builtins.str, optional
                    Root of this backend.
                secret_id : builtins.str, optional
                    Secret ID of this backend.
                secret_key : builtins.str, optional
                    Secret key of this backend.
                security_token : builtins.str, optional
                    Security token (a.k.a.
                    session token) of this backend.
                    This is used for temporary credentials issued by
                    Tencent Cloud STS (e.g.
                    `GetFederationToken` / `AssumeRole`).
                    When `security_token` is provided, it will be used
                    together with `secret_id` and `secret_key` to sign
                    requests, and the `x-cos-security-token` header will
                    be attached automatically by the signer.
                    If this field is not set, OpenDAL will also fall
                    back to reading the token from environment variables
                    `TENCENTCLOUD_TOKEN`, `TENCENTCLOUD_SECURITY_TOKEN`
                    or `QCLOUD_SECRET_TOKEN` (unless
                    `disable_config_load` is enabled).
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `cos` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Dashmap, "dashmap"],
                /,
                *,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `dashmap` service.

                Parameters
                ----------
                root : builtins.str, optional
                    root path of this backend
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `dashmap` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Dropbox, "dropbox"],
                /,
                *,
                access_token: builtins.str = ...,
                client_id: builtins.str = ...,
                client_secret: builtins.str = ...,
                refresh_token: builtins.str = ...,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `dropbox` service.

                Parameters
                ----------
                access_token : builtins.str, optional
                    access token for dropbox.
                client_id : builtins.str, optional
                    client_id for dropbox.
                client_secret : builtins.str, optional
                    client_secret for dropbox.
                refresh_token : builtins.str, optional
                    refresh_token for dropbox.
                root : builtins.str, optional
                    root path for dropbox.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `dropbox` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Fs, "fs"],
                /,
                *,
                atomic_write_dir: builtins.str = ...,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `fs` service.

                Parameters
                ----------
                atomic_write_dir : builtins.str, optional
                    tmp dir for atomic write
                root : builtins.str, optional
                    root dir for backend
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `fs` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Ftp, "ftp"],
                /,
                *,
                endpoint: builtins.str = ...,
                password: builtins.str = ...,
                root: builtins.str = ...,
                user: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `ftp` service.

                Parameters
                ----------
                endpoint : builtins.str, optional
                    endpoint of this backend
                password : builtins.str, optional
                    password of this backend
                root : builtins.str, optional
                    root of this backend
                user : builtins.str, optional
                    user of this backend
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `ftp` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Gcs, "gcs"],
                /,
                *,
                allow_anonymous: builtins.bool = ...,
                bucket: builtins.str,
                credential: builtins.str = ...,
                credential_path: builtins.str = ...,
                default_storage_class: builtins.str = ...,
                disable_config_load: builtins.bool = ...,
                disable_vm_metadata: builtins.bool = ...,
                endpoint: builtins.str = ...,
                predefined_acl: builtins.str = ...,
                root: builtins.str = ...,
                scope: builtins.str = ...,
                service_account: builtins.str = ...,
                skip_signature: builtins.bool = ...,
                token: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `gcs` service.

                Parameters
                ----------
                allow_anonymous : builtins.bool, optional
                    Allow opendal to send requests without signing when
                    credentials are not loaded.
                bucket : builtins.str
                    bucket name
                credential : builtins.str, optional
                    Credentials string for GCS service OAuth2
                    authentication.
                credential_path : builtins.str, optional
                    Local path to credentials file for GCS service
                    OAuth2 authentication.
                default_storage_class : builtins.str, optional
                    The default storage class used by gcs.
                disable_config_load : builtins.bool, optional
                    Disable loading configuration from the environment.
                disable_vm_metadata : builtins.bool, optional
                    Disable attempting to load credentials from the GCE
                    metadata server when running within Google Cloud.
                endpoint : builtins.str, optional
                    endpoint URI of GCS service, default is
                    `https://storage.googleapis.com`
                predefined_acl : builtins.str, optional
                    The predefined acl for GCS.
                root : builtins.str, optional
                    root URI, all operations happens under `root`
                scope : builtins.str, optional
                    Scope for gcs.
                service_account : builtins.str, optional
                    Service Account for gcs.
                skip_signature : builtins.bool, optional
                    Skip signature will skip loading credentials and
                    signing requests.
                token : builtins.str, optional
                    A Google Cloud OAuth2 token.
                    Takes precedence over `credential` and
                    `credential_path`.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `gcs` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Gdrive, "gdrive"],
                /,
                *,
                access_token: builtins.str = ...,
                client_id: builtins.str = ...,
                client_secret: builtins.str = ...,
                refresh_token: builtins.str = ...,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `gdrive` service.

                Parameters
                ----------
                access_token : builtins.str, optional
                    Access token for gdrive.
                client_id : builtins.str, optional
                    Client id for gdrive.
                client_secret : builtins.str, optional
                    Client secret for gdrive.
                refresh_token : builtins.str, optional
                    Refresh token for gdrive.
                root : builtins.str, optional
                    The root for gdrive
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `gdrive` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Ghac, "ghac"],
                /,
                *,
                endpoint: builtins.str = ...,
                root: builtins.str = ...,
                runtime_token: builtins.str = ...,
                version: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `ghac` service.

                Parameters
                ----------
                endpoint : builtins.str, optional
                    The endpoint for ghac service.
                root : builtins.str, optional
                    The root path for ghac.
                runtime_token : builtins.str, optional
                    The runtime token for ghac service.
                version : builtins.str, optional
                    The version that used by cache.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `ghac` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Goosefs, "goosefs"],
                /,
                *,
                auth_type: builtins.str = ...,
                auth_username: builtins.str = ...,
                block_size: builtins.int = ...,
                chunk_size: builtins.int = ...,
                master_addr: builtins.str = ...,
                root: builtins.str = ...,
                write_type: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `goosefs` service.

                Parameters
                ----------
                auth_type : builtins.str, optional
                    Authentication type.
                    Supported values: `"nosasl"`, `"simple"`.
                    Default: `"simple"` — PLAIN SASL with usernam
                    e. `"nosasl"` — skip authentication entirely.
                auth_username : builtins.str, optional
                    Authentication username.
                    Used in SIMPLE mode as the login identity.
                    Default: current OS user (`$USER` / `$USERNAME`).
                block_size : builtins.int, optional
                    Block size in bytes for new files (default: 64 MiB).
                chunk_size : builtins.int, optional
                    Chunk size in bytes for streaming RPCs (default: 1
                    MiB).
                master_addr : builtins.str, optional
                    Master address(es) in `host:port` format.
                    For single master: `"10.0.0.1:9200"` For HA
                    (comma-separated):
                    `"10.0.0.1:9200,10.0.0.2:9200,10.0.0.3:9200"` When
                    multiple addresses are provided, the client uses
                    `PollingMasterInquireClient` to discover the Primary
                    Master automatically.
                    Resolution precedence at `build()` time (highest →
                    lowest), following `goosefs-sdk`
                    `docs/CLIENT_CONFIGURATION.md` §1:
                    1. This field (when set on the builder / OpenDAL
                    config map)
                    2. `GOOSEFS_MASTER_ADDR` environment variable
                    3. `goosefs.master.rpc.addresses` /
                    `goosefs.master.hostname` in
                    `goosefs-site.properties` `build()` fails with
                    `ConfigInvalid` only when **none** of the above
                    supplies a master address.
                root : builtins.str, optional
                    Root path of this backend.
                    All operations will happen under this root.
                    Default to `/` if not set.
                write_type : builtins.str, optional
                    Default write type for new files.
                    Supported values: `"must_cache"`, `"cache_through"`,
                    `"through"`, `"async_through"`.
                    Default: `"must_cache"`.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `goosefs` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Gridfs, "gridfs"],
                /,
                *,
                bucket: builtins.str = ...,
                chunk_size: builtins.int = ...,
                connection_string: builtins.str = ...,
                database: builtins.str = ...,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `gridfs` service.

                Parameters
                ----------
                bucket : builtins.str, optional
                    The bucket name of the MongoDB GridFs service to
                    read/write.
                chunk_size : builtins.int, optional
                    The chunk size of the MongoDB GridFs service used to
                    break the user file into chunks.
                connection_string : builtins.str, optional
                    The connection string of the MongoDB service.
                database : builtins.str, optional
                    The database name of the MongoDB GridFs service to
                    read/write.
                root : builtins.str, optional
                    The working directory, all operations will be
                    performed under it.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `gridfs` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.HdfsNative, "hdfs-native"],
                /,
                *,
                enable_append: builtins.bool = ...,
                name_node: builtins.str = ...,
                options: builtins.dict = ...,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `hdfs-native` service.

                Parameters
                ----------
                enable_append : builtins.bool, optional
                    Deprecated: HDFS Native append capability is enabled
                    by default.
                name_node : builtins.str, optional
                    name_node of this backend
                options : builtins.dict, optional
                    other options for hdfs client
                root : builtins.str, optional
                    work dir of this backend
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `hdfs-native` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Hf, "hf"],
                /,
                *,
                download_mode: builtins.str = ...,
                endpoint: builtins.str = ...,
                repo_id: builtins.str = ...,
                repo_type: builtins.str = ...,
                revision: builtins.str = ...,
                root: builtins.str = ...,
                token: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `hf` service.

                Parameters
                ----------
                download_mode : builtins.str, optional
                    Download mode.
                    Either `xet` (default) or `http`.
                endpoint : builtins.str, optional
                    Endpoint of the Hugging Face Hub.
                    Default is "https://huggingface.co".
                repo_id : builtins.str, optional
                    Repo id of this backend.
                    This is required.
                repo_type : builtins.str, optional
                    Repo type of this backend.
                    Required.
                revision : builtins.str, optional
                    Revision of this backend.
                    Default is main.
                root : builtins.str, optional
                    Root of this backend.
                    Can be "/path/to/dir".
                    Default is "/".
                token : builtins.str, optional
                    Token of this backend.
                    This is optional.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `hf` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Http, "http"],
                /,
                *,
                endpoint: builtins.str = ...,
                password: builtins.str = ...,
                root: builtins.str = ...,
                token: builtins.str = ...,
                username: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `http` service.

                Parameters
                ----------
                endpoint : builtins.str, optional
                    endpoint of this backend
                password : builtins.str, optional
                    password of this backend
                root : builtins.str, optional
                    root of this backend
                token : builtins.str, optional
                    token of this backend
                username : builtins.str, optional
                    username of this backend
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `http` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Ipfs, "ipfs"],
                /,
                *,
                endpoint: builtins.str = ...,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `ipfs` service.

                Parameters
                ----------
                endpoint : builtins.str, optional
                    IPFS gateway endpoint.
                root : builtins.str, optional
                    IPFS root.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `ipfs` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Ipmfs, "ipmfs"],
                /,
                *,
                endpoint: builtins.str = ...,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `ipmfs` service.

                Parameters
                ----------
                endpoint : builtins.str, optional
                    Endpoint for ipfs.
                root : builtins.str, optional
                    Root for ipfs.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `ipmfs` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Koofr, "koofr"],
                /,
                *,
                email: builtins.str,
                endpoint: builtins.str,
                password: builtins.str = ...,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `koofr` service.

                Parameters
                ----------
                email : builtins.str
                    Koofr email.
                endpoint : builtins.str
                    Koofr endpoint.
                password : builtins.str, optional
                    password of this backend.
                    (Must be the application password)
                root : builtins.str, optional
                    root of this backend.
                    All operations will happen under this root.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `koofr` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Memcached, "memcached"],
                /,
                *,
                connection_pool_max_size: builtins.int = ...,
                default_ttl: typing.Any = ...,
                endpoint: builtins.str = ...,
                password: builtins.str = ...,
                root: builtins.str = ...,
                username: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `memcached` service.

                Parameters
                ----------
                connection_pool_max_size : builtins.int, optional
                    The maximum number of connections allowed.
                    default is 10
                default_ttl : typing.Any, optional
                    The default ttl for put operations..
                    a human readable duration string see
                    https://docs.rs/humantime/latest/humantime/fn.parse_duration.html
                    for more details
                endpoint : builtins.str, optional
                    network address of the memcached service.
                    For example: "tcp://localhost:11211"
                password : builtins.str, optional
                    Memcached password, optional.
                root : builtins.str, optional
                    the working directory of the service.
                    Can be "/path/to/dir" default is "/"
                username : builtins.str, optional
                    Memcached username, optional.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `memcached` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Memory, "memory"],
                /,
                *,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `memory` service.

                Parameters
                ----------
                root : builtins.str, optional
                    root of the backend.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `memory` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.MiniMoka, "mini-moka"],
                /,
                *,
                max_capacity: builtins.int = ...,
                root: builtins.str = ...,
                time_to_idle: builtins.str = ...,
                time_to_live: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `mini-moka` service.

                Parameters
                ----------
                max_capacity : builtins.int, optional
                    Sets the max capacity of the cache.
                    Refer to
                    [`mini-moka::sync::CacheBuilder::max_capacity`](https://docs.rs/mini-moka/latest/mini_moka/sync/struct.CacheBuilder.html#method.max_capacity)
                root : builtins.str, optional
                    root path of this backend
                time_to_idle : builtins.str, optional
                    Sets the time to idle of the cache.
                    Refer to
                    [`mini-moka::sync::CacheBuilder::time_to_idle`](https://docs.rs/mini-moka/latest/mini_moka/sync/struct.CacheBuilder.html#method.time_to_idle)
                time_to_live : builtins.str, optional
                    Sets the time to live of the cache.
                    Refer to
                    [`mini-moka::sync::CacheBuilder::time_to_live`](https://docs.rs/mini-moka/latest/mini_moka/sync/struct.CacheBuilder.html#method.time_to_live)
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `mini-moka` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Moka, "moka"],
                /,
                *,
                max_capacity: builtins.int = ...,
                name: builtins.str = ...,
                root: builtins.str = ...,
                time_to_idle: builtins.str = ...,
                time_to_live: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `moka` service.

                Parameters
                ----------
                max_capacity : builtins.int, optional
                    Sets the max capacity of the cache.
                    Refer to
                    [`moka::future::CacheBuilder::max_capacity`](https://docs.rs/moka/latest/moka/future/struct.CacheBuilder.html#method.max_capacity)
                name : builtins.str, optional
                    Name for this cache instance.
                root : builtins.str, optional
                    root path of this backend
                time_to_idle : builtins.str, optional
                    Sets the time to idle of the cache.
                    Refer to
                    [`moka::future::CacheBuilder::time_to_idle`](https://docs.rs/moka/latest/moka/future/struct.CacheBuilder.html#method.time_to_idle)
                time_to_live : builtins.str, optional
                    Sets the time to live of the cache.
                    Refer to
                    [`moka::future::CacheBuilder::time_to_live`](https://docs.rs/moka/latest/moka/future/struct.CacheBuilder.html#method.time_to_live)
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `moka` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Mongodb, "mongodb"],
                /,
                *,
                collection: builtins.str = ...,
                connection_string: builtins.str = ...,
                database: builtins.str = ...,
                key_field: builtins.str = ...,
                root: builtins.str = ...,
                value_field: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `mongodb` service.

                Parameters
                ----------
                collection : builtins.str, optional
                    collection of this backend
                connection_string : builtins.str, optional
                    connection string of this backend
                database : builtins.str, optional
                    database of this backend
                key_field : builtins.str, optional
                    key field of this backend
                root : builtins.str, optional
                    root of this backend
                value_field : builtins.str, optional
                    value field of this backend
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `mongodb` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Mysql, "mysql"],
                /,
                *,
                connection_string: builtins.str = ...,
                key_field: builtins.str = ...,
                root: builtins.str = ...,
                table: builtins.str = ...,
                value_field: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `mysql` service.

                Parameters
                ----------
                connection_string : builtins.str, optional
                    This connection string is used to connect to the
                    mysql service.
                    There are url based formats.
                    The format of connect string resembles the url
                    format of the mysql client.
                    The format is:
                    `[scheme://][user[:[password]]@]host[:port][/schema][?attribute1=value1&attribute2=value2...`
                    - `mysql://user@localhost` -
                    `mysql://user:password@localhost` -
                    `mysql://user:password@localhost:3306` -
                    `mysql://user:password@localhost:3306/db` For more
                    information, please refer to
                    <https://docs.rs/sqlx/latest/sqlx/mysql/struct.MySqlConnectOptions.html>.
                key_field : builtins.str, optional
                    The key field name for mysql.
                root : builtins.str, optional
                    The root for mysql.
                table : builtins.str, optional
                    The table name for mysql.
                value_field : builtins.str, optional
                    The value field name for mysql.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `mysql` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Obs, "obs"],
                /,
                *,
                access_key_id: builtins.str = ...,
                bucket: builtins.str = ...,
                enable_versioning: builtins.bool = ...,
                endpoint: builtins.str = ...,
                root: builtins.str = ...,
                secret_access_key: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `obs` service.

                Parameters
                ----------
                access_key_id : builtins.str, optional
                    Access key id for obs.
                bucket : builtins.str, optional
                    Bucket for obs.
                enable_versioning : builtins.bool, optional
                    Deprecated: OBS versioning capability is not
                    controlled by service config.
                endpoint : builtins.str, optional
                    Endpoint for obs.
                root : builtins.str, optional
                    Root for obs.
                secret_access_key : builtins.str, optional
                    Secret access key for obs.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `obs` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Onedrive, "onedrive"],
                /,
                *,
                access_token: builtins.str = ...,
                client_id: builtins.str = ...,
                client_secret: builtins.str = ...,
                enable_versioning: builtins.bool = ...,
                refresh_token: builtins.str = ...,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `onedrive` service.

                Parameters
                ----------
                access_token : builtins.str, optional
                    Microsoft Graph API (also OneDrive API) access token
                client_id : builtins.str, optional
                    Microsoft Graph API Application (client) ID that is
                    in the Azure's app registration portal
                client_secret : builtins.str, optional
                    Microsoft Graph API Application client secret that
                    is in the Azure's app registration portal
                enable_versioning : builtins.bool, optional
                    Deprecated: OneDrive versioning capability is
                    enabled by default.
                refresh_token : builtins.str, optional
                    Microsoft Graph API (also OneDrive API) refresh
                    token
                root : builtins.str, optional
                    The root path for the OneDrive service for the file
                    access
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `onedrive` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Oss, "oss"],
                /,
                *,
                access_key_id: builtins.str = ...,
                access_key_secret: builtins.str = ...,
                addressing_style: builtins.str = ...,
                allow_anonymous: builtins.bool = ...,
                batch_max_operations: builtins.int = ...,
                bucket: builtins.str,
                delete_max_size: builtins.int = ...,
                enable_versioning: builtins.bool = ...,
                endpoint: builtins.str = ...,
                external_id: builtins.str = ...,
                oidc_provider_arn: builtins.str = ...,
                oidc_token_file: builtins.str = ...,
                presign_addressing_style: builtins.str = ...,
                presign_endpoint: builtins.str = ...,
                role_arn: builtins.str = ...,
                role_session_name: builtins.str = ...,
                root: builtins.str = ...,
                security_token: builtins.str = ...,
                server_side_encryption: builtins.str = ...,
                server_side_encryption_key_id: builtins.str = ...,
                skip_signature: builtins.bool = ...,
                sts_endpoint: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `oss` service.

                Parameters
                ----------
                access_key_id : builtins.str, optional
                    Access key id for oss.
                    - this field if it's `is_some` - env value:
                    `ALIBABA_CLOUD_ACCESS_KEY_ID`
                access_key_secret : builtins.str, optional
                    Access key secret for oss.
                    - this field if it's `is_some` - env value:
                    `ALIBABA_CLOUD_ACCESS_KEY_SECRET`
                addressing_style : builtins.str, optional
                    Addressing style for oss.
                allow_anonymous : builtins.bool, optional
                    Allow anonymous for oss.
                batch_max_operations : builtins.int, optional
                    Deprecated: OSS delete batch capability is enabled
                    by default.
                bucket : builtins.str
                    Bucket for oss.
                delete_max_size : builtins.int, optional
                    Deprecated: OSS delete batch capability is enabled
                    by default.
                enable_versioning : builtins.bool, optional
                    Deprecated: OSS versioning capability is enabled by
                    default.
                endpoint : builtins.str, optional
                    Endpoint for oss.
                external_id : builtins.str, optional
                    external_id for this backend.
                oidc_provider_arn : builtins.str, optional
                    `oidc_provider_arn` will be loaded from - this field
                    if it's `is_some` - env value:
                    `ALIBABA_CLOUD_OIDC_PROVIDER_ARN`
                oidc_token_file : builtins.str, optional
                    `oidc_token_file` will be loaded from - this field
                    if it's `is_some` - env value:
                    `ALIBABA_CLOUD_OIDC_TOKEN_FILE`
                presign_addressing_style : builtins.str, optional
                    Pre sign addressing style for oss.
                presign_endpoint : builtins.str, optional
                    Presign endpoint for oss.
                role_arn : builtins.str, optional
                    If `role_arn` is set, we will use already known
                    config as source credential to assume role with
                    `role_arn`.
                    - this field if it's `is_some` - env value:
                    `ALIBABA_CLOUD_ROLE_ARN`
                role_session_name : builtins.str, optional
                    role_session_name for this backend.
                root : builtins.str, optional
                    Root for oss.
                security_token : builtins.str, optional
                    `security_token` will be loaded from - this field if
                    it's `is_some` - env value:
                    `ALIBABA_CLOUD_SECURITY_TOKEN`
                server_side_encryption : builtins.str, optional
                    Server side encryption for oss.
                server_side_encryption_key_id : builtins.str, optional
                    Server side encryption key id for oss.
                skip_signature : builtins.bool, optional
                    Skip signature will skip loading credentials and
                    signing requests.
                sts_endpoint : builtins.str, optional
                    `sts_endpoint` will be loaded from - this field if
                    it's `is_some` - env value:
                    `ALIBABA_CLOUD_STS_ENDPOINT`
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `oss` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Persy, "persy"],
                /,
                *,
                datafile: builtins.str = ...,
                index: builtins.str = ...,
                segment: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `persy` service.

                Parameters
                ----------
                datafile : builtins.str, optional
                    That path to the persy data file.
                    The directory in the path must already exist.
                index : builtins.str, optional
                    That name of the persy index.
                segment : builtins.str, optional
                    That name of the persy segment.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `persy` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Postgresql, "postgresql"],
                /,
                *,
                connection_string: builtins.str = ...,
                key_field: builtins.str = ...,
                root: builtins.str = ...,
                table: builtins.str = ...,
                value_field: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `postgresql` service.

                Parameters
                ----------
                connection_string : builtins.str, optional
                    The URL should be with a scheme of either
                    `postgres://` or `postgresql://`.
                    - `postgresql://user@localhost` -
                    `postgresql://user:password@%2Fvar%2Flib%2Fpostgresql/mydb?connect_timeout=10`
                    -
                    `postgresql://user@host1:1234,host2,host3:5678?target_session_attrs=read-write`
                    -
                    `postgresql:///mydb?user=user&host=/var/lib/postgresql`
                    For more information, please visit
                    <https://docs.rs/sqlx/latest/sqlx/postgres/struct.PgConnectOptions.html>.
                key_field : builtins.str, optional
                    the key field of postgresql
                root : builtins.str, optional
                    Root of this backend.
                    All operations will happen under this root.
                    Default to `/` if not set.
                table : builtins.str, optional
                    the table of postgresql
                value_field : builtins.str, optional
                    the value field of postgresql
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `postgresql` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Redb, "redb"],
                /,
                *,
                datadir: builtins.str = ...,
                root: builtins.str = ...,
                table: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `redb` service.

                Parameters
                ----------
                datadir : builtins.str, optional
                    path to the redb data directory.
                root : builtins.str, optional
                    The root for redb.
                table : builtins.str, optional
                    The table name for redb.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `redb` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Redis, "redis"],
                /,
                *,
                cluster_endpoints: builtins.str = ...,
                connection_pool_max_size: builtins.int = ...,
                db: builtins.int,
                default_ttl: typing.Any = ...,
                endpoint: builtins.str = ...,
                password: builtins.str = ...,
                root: builtins.str = ...,
                username: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `redis` service.

                Parameters
                ----------
                cluster_endpoints : builtins.str, optional
                    network address of the Redis cluster service.
                    Can be
                    "tcp://127.0.0.1:6379,tcp://127.0.0.1:6380,tcp://127.0.0.1:6381",
                    e.g.
                    default is None
                connection_pool_max_size : builtins.int, optional
                    The maximum number of connections allowed.
                    default is 10
                db : builtins.int
                    the number of DBs redis can take is unlimited
                    default is db 0
                default_ttl : typing.Any, optional
                    The default ttl for put operations..
                    a human readable duration string see
                    https://docs.rs/humantime/latest/humantime/fn.parse_duration.html
                    for more details
                endpoint : builtins.str, optional
                    network address of the Redis service.
                    Can be "tcp://127.0.0.1:6379", e.g.
                    default is "tcp://127.0.0.1:6379"
                password : builtins.str, optional
                    the password for authentication default is None
                root : builtins.str, optional
                    the working directory of the Redis service.
                    Can be "/path/to/dir" default is "/"
                username : builtins.str, optional
                    the username to connect redis service.
                    default is None
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `redis` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.S3, "s3"],
                /,
                *,
                access_key_id: builtins.str = ...,
                allow_anonymous: builtins.bool = ...,
                assume_role_duration_seconds: builtins.int = ...,
                assume_role_session_tags: builtins.dict = ...,
                batch_max_operations: builtins.int = ...,
                bucket: builtins.str,
                checksum_algorithm: builtins.str = ...,
                default_acl: builtins.str = ...,
                default_storage_class: builtins.str = ...,
                delete_max_size: builtins.int = ...,
                disable_config_load: builtins.bool = ...,
                disable_ec2_metadata: builtins.bool = ...,
                disable_list_objects_v2: builtins.bool = ...,
                disable_stat_with_override: builtins.bool = ...,
                disable_write_with_if_match: builtins.bool = ...,
                enable_request_payer: builtins.bool = ...,
                enable_versioning: builtins.bool = ...,
                enable_virtual_host_style: builtins.bool = ...,
                enable_write_with_append: builtins.bool = ...,
                endpoint: builtins.str = ...,
                external_id: builtins.str = ...,
                region: builtins.str = ...,
                role_arn: builtins.str = ...,
                role_session_name: builtins.str = ...,
                root: builtins.str = ...,
                secret_access_key: builtins.str = ...,
                server_side_encryption: builtins.str = ...,
                server_side_encryption_aws_kms_key_id: builtins.str = ...,
                server_side_encryption_customer_algorithm: builtins.str = ...,
                server_side_encryption_customer_key: builtins.str = ...,
                server_side_encryption_customer_key_md5: builtins.str = ...,
                session_token: builtins.str = ...,
                skip_signature: builtins.bool = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `s3` service.

                Parameters
                ----------
                access_key_id : builtins.str, optional
                    access_key_id of this backend.
                    - If access_key_id is set, we will take user's input
                    first.
                    - If not, we will try to load it from environment.
                allow_anonymous : builtins.bool, optional
                    Allow anonymous will allow opendal to send request
                    without signing when credential is not loaded.
                assume_role_duration_seconds : builtins.int, optional
                    assume_role_duration_seconds for this backend.
                assume_role_session_tags : builtins.dict, optional
                    assume_role_session_tags for this backend.
                batch_max_operations : builtins.int, optional
                    Deprecated: S3 delete batch capability is enabled by
                    default.
                bucket : builtins.str
                    bucket name of this backend.
                    required.
                checksum_algorithm : builtins.str, optional
                    Checksum Algorithm to use when sending checksums in
                    HTTP headers.
                    This is necessary when writing to AWS S3 Buckets
                    with Object Lock enabled for example.
                    Available options: - "crc32c" - "md5"
                default_acl : builtins.str, optional
                    Default ACL for new objects.
                    Note that some s3 services like minio do not support
                    this option.
                default_storage_class : builtins.str, optional
                    default storage_class for this backend.
                    Available values: - `DEEP_ARCHIVE` - `GLACIER` -
                    `GLACIER_IR` - `INTELLIGENT_TIERING` - `ONEZONE_IA`
                    - `EXPRESS_ONEZONE` - `OUTPOSTS` -
                    `REDUCED_REDUNDANCY` - `STANDARD` - `STANDARD_IA` S3
                    compatible services don't support all of them
                delete_max_size : builtins.int, optional
                    Deprecated: S3 delete batch capability is enabled by
                    default.
                disable_config_load : builtins.bool, optional
                    Disable config load so that opendal will not load
                    config from environment.
                    For examples: - envs like `AWS_ACCESS_KEY_ID` -
                    files like `~/.aws/config`
                disable_ec2_metadata : builtins.bool, optional
                    Disable load credential from ec2 metadata.
                    This option is used to disable the default behavior
                    of opendal to load credential from ec2 metadata,
                    a.k.a., IMDSv2
                disable_list_objects_v2 : builtins.bool, optional
                    OpenDAL uses List Objects V2 by default to list
                    objects.
                    However, some legacy services do not yet support V2.
                    This option allows users to switch back to the older
                    List Objects V1.
                disable_stat_with_override : builtins.bool, optional
                    Deprecated: S3 stat override capabilities are
                    enabled by default.
                disable_write_with_if_match : builtins.bool, optional
                    Deprecated: S3 write with If-Match capability is
                    enabled by default.
                enable_request_payer : builtins.bool, optional
                    Indicates whether the client agrees to pay for the
                    requests made to the S3 bucket.
                enable_versioning : builtins.bool, optional
                    Deprecated: S3 versioning capability is enabled by
                    default.
                enable_virtual_host_style : builtins.bool, optional
                    Enable virtual host style so that opendal will send
                    API requests in virtual host style instead of path
                    style.
                    - By default, opendal will send API to
                    `https://s3.us-east-1.amazonaws.com/bucket_name` -
                    Enabled, opendal will send API to
                    `https://bucket_name.s3.us-east-1.amazonaws.com`
                enable_write_with_append : builtins.bool, optional
                    Deprecated: S3 append capability is enabled by
                    default.
                endpoint : builtins.str, optional
                    endpoint of this backend.
                    Endpoint must be full uri, e.g.
                    - AWS S3: `https://s3.amazonaws.com` or
                    `https://s3.{region}.amazonaws.com` - Cloudflare R2:
                    `https://<ACCOUNT_ID>.r2.cloudflarestorage.com` -
                    Aliyun OSS: `https://{region}.aliyuncs.com` -
                    Tencent COS: `https://cos.{region}.myqcloud.com` -
                    Minio: `http://127.0.0.1:9000` If user inputs
                    endpoint without scheme like "s3.amazonaws.com", we
                    will prepend "https://" before it.
                    - If endpoint is set, we will take user's input
                    first.
                    - If not, we will try to load it from environment.
                    - If still not set, default to
                    `https://s3.amazonaws.com`.
                external_id : builtins.str, optional
                    external_id for this backend.
                region : builtins.str, optional
                    Region represent the signing region of this
                    endpoint.
                    This is required if you are using the default AWS S3
                    endpoint.
                    If using a custom endpoint, - If region is set, we
                    will take user's input first.
                    - If not, we will try to load it from environment.
                role_arn : builtins.str, optional
                    role_arn for this backend.
                    If `role_arn` is set, we will use already known
                    config as source credential to assume role with
                    `role_arn`.
                role_session_name : builtins.str, optional
                    role_session_name for this backend.
                root : builtins.str, optional
                    root of this backend.
                    All operations will happen under this root.
                    default to `/` if not set.
                secret_access_key : builtins.str, optional
                    secret_access_key of this backend.
                    - If secret_access_key is set, we will take user's
                    input first.
                    - If not, we will try to load it from environment.
                server_side_encryption : builtins.str, optional
                    server_side_encryption for this backend.
                    Available values: `AES256`, `aws:kms`.
                server_side_encryption_aws_kms_key_id : builtins.str, optional
                    server_side_encryption_aws_kms_key_id for this
                    backend - If `server_side_encryption` set to
                    `aws:kms`, and
                    `server_side_encryption_aws_kms_key_id` is not set,
                    S3 will use aws managed kms key to encrypt data.
                    - If `server_side_encryption` set to `aws:kms`, and
                    `server_side_encryption_aws_kms_key_id` is a valid
                    kms key id, S3 will use the provided kms key to
                    encrypt data.
                    - If the `server_side_encryption_aws_kms_key_id` is
                    invalid or not found, an error will be returned.
                    - If `server_side_encryption` is not `aws:kms`,
                    setting `server_side_encryption_aws_kms_key_id` is a
                    noop.
                server_side_encryption_customer_algorithm : builtins.str, optional
                    server_side_encryption_customer_algorithm for this
                    backend.
                    Available values: `AES256`.
                server_side_encryption_customer_key : builtins.str, optional
                    server_side_encryption_customer_key for this
                    backend.
                    Value: BASE64-encoded key that matches algorithm
                    specified in
                    `server_side_encryption_customer_algorithm`.
                server_side_encryption_customer_key_md5 : builtins.str, optional
                    Set server_side_encryption_customer_key_md5 for this
                    backend.
                    Value: MD5 digest of key specified in
                    `server_side_encryption_customer_key`.
                session_token : builtins.str, optional
                    session_token (aka, security token) of this backend.
                    This token will expire after sometime, it's
                    recommended to set session_token by hand.
                skip_signature : builtins.bool, optional
                    Skip signature will skip loading credentials and
                    signing requests.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `s3` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Seafile, "seafile"],
                /,
                *,
                endpoint: builtins.str = ...,
                password: builtins.str = ...,
                repo_name: builtins.str,
                root: builtins.str = ...,
                username: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `seafile` service.

                Parameters
                ----------
                endpoint : builtins.str, optional
                    endpoint address of this backend.
                password : builtins.str, optional
                    password of this backend.
                repo_name : builtins.str
                    repo_name of this backend.
                    required.
                root : builtins.str, optional
                    root of this backend.
                    All operations will happen under this root.
                username : builtins.str, optional
                    username of this backend.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `seafile` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Sftp, "sftp"],
                /,
                *,
                enable_copy: builtins.bool = ...,
                endpoint: builtins.str = ...,
                key: builtins.str = ...,
                known_hosts_strategy: builtins.str = ...,
                root: builtins.str = ...,
                user: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `sftp` service.

                Parameters
                ----------
                enable_copy : builtins.bool, optional
                    Deprecated: SFTP copy capability is enabled by
                    default.
                endpoint : builtins.str, optional
                    endpoint of this backend
                key : builtins.str, optional
                    key of this backend
                known_hosts_strategy : builtins.str, optional
                    known_hosts_strategy of this backend
                root : builtins.str, optional
                    root of this backend
                user : builtins.str, optional
                    user of this backend
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `sftp` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Sled, "sled"],
                /,
                *,
                datadir: builtins.str = ...,
                root: builtins.str = ...,
                tree: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `sled` service.

                Parameters
                ----------
                datadir : builtins.str, optional
                    That path to the sled data directory.
                root : builtins.str, optional
                    The root for sled.
                tree : builtins.str, optional
                    The tree for sled.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `sled` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Sqlite, "sqlite"],
                /,
                *,
                connection_string: builtins.str = ...,
                key_field: builtins.str = ...,
                root: builtins.str = ...,
                table: builtins.str = ...,
                value_field: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `sqlite` service.

                Parameters
                ----------
                connection_string : builtins.str, optional
                    Set the connection_string of the sqlite service.
                    This connection string is used to connect to the
                    sqlite service.
                    The format of connect string resembles the url
                    format of the sqlite client: - `sqlite::memory:` -
                    `sqlite:data.db` - `sqlite://data.db` For more
                    information, please visit
                    <https://docs.rs/sqlx/latest/sqlx/sqlite/struct.SqliteConnectOptions.html>.
                key_field : builtins.str, optional
                    Set the key field name of the sqlite service to
                    read/write.
                    Default to `key` if not specified.
                root : builtins.str, optional
                    set the working directory, all operations will be
                    performed under it.
                    default: "/"
                table : builtins.str, optional
                    Set the table name of the sqlite service to
                    read/write.
                value_field : builtins.str, optional
                    Set the value field name of the sqlite service to
                    read/write.
                    Default to `value` if not specified.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `sqlite` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Swift, "swift"],
                /,
                *,
                container: builtins.str = ...,
                endpoint: builtins.str = ...,
                root: builtins.str = ...,
                temp_url_hash_algorithm: builtins.str = ...,
                temp_url_key: builtins.str = ...,
                token: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `swift` service.

                Parameters
                ----------
                container : builtins.str, optional
                    The container for Swift.
                endpoint : builtins.str, optional
                    The endpoint for Swift.
                root : builtins.str, optional
                    The root for Swift.
                temp_url_hash_algorithm : builtins.str, optional
                    The hash algorithm for TempURL signing.
                    Supported values: `sha1`, `sha256`, `sha512`.
                    Defaults to `sha256`.
                    The cluster must have the chosen algorithm in its
                    `tempurl.allowed_digests` (check `GET /info`).
                temp_url_key : builtins.str, optional
                    The TempURL key for generating presigned URLs.
                    This corresponds to the
                    `X-Account-Meta-Temp-URL-Key` or
                    `X-Container-Meta-Temp-URL-Key` header value
                    configured on the Swift account or container.
                token : builtins.str, optional
                    The token for Swift.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `swift` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Tos, "tos"],
                /,
                *,
                access_key_id: builtins.str = ...,
                bucket: builtins.str,
                disable_config_load: builtins.bool = ...,
                endpoint: builtins.str = ...,
                region: builtins.str = ...,
                root: builtins.str = ...,
                secret_access_key: builtins.str = ...,
                security_token: builtins.str = ...,
                skip_signature: builtins.bool = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `tos` service.

                Parameters
                ----------
                access_key_id : builtins.str, optional
                    access_key_id of this backend.
                    - If access_key_id is set, we will take user's input
                    first.
                    - If not, we will try to load it from environment.
                bucket : builtins.str
                    bucket name of this backend.
                    required.
                disable_config_load : builtins.bool, optional
                    Disable config load so that opendal will not load
                    config from environment.
                    For examples: - envs like `TOS_ACCESS_KEY_ID`
                endpoint : builtins.str, optional
                    endpoint of this backend.
                    Endpoint must be full uri, e.g.
                    - TOS: `https://tos-cn-beijing.volces.com` - TOS
                    with region: `https://tos-{region}.volces.com` If
                    user inputs endpoint without scheme like
                    "tos-cn-beijing.volces.com", we will prepend
                    "https://" before it.
                region : builtins.str, optional
                    Region represent the signing region of this
                    endpoint.
                    Required if endpoint is not provided.
                    - If region is set, we will take user's input first.
                    - If not, we will try to load it from environment.
                    - If still not set, default to `cn-beijing`.
                root : builtins.str, optional
                    root of this backend.
                    All operations will happen under this root.
                    default to `/` if not set.
                secret_access_key : builtins.str, optional
                    secret_access_key of this backend.
                    - If secret_access_key is set, we will take user's
                    input first.
                    - If not, we will try to load it from environment.
                security_token : builtins.str, optional
                    security_token of this backend.
                    This token will expire after sometime, it's
                    recommended to set security_token by hand.
                skip_signature : builtins.bool, optional
                    Skip signature will skip loading credentials and
                    signing requests.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `tos` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Upyun, "upyun"],
                /,
                *,
                bucket: builtins.str,
                operator: builtins.str = ...,
                password: builtins.str = ...,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `upyun` service.

                Parameters
                ----------
                bucket : builtins.str
                    bucket address of this backend.
                operator : builtins.str, optional
                    username of this backend.
                password : builtins.str, optional
                    password of this backend.
                root : builtins.str, optional
                    root of this backend.
                    All operations will happen under this root.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `upyun` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.VercelArtifacts, "vercel-artifacts"],
                /,
                *,
                access_token: builtins.str = ...,
                endpoint: builtins.str = ...,
                team_id: builtins.str = ...,
                team_slug: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `vercel-artifacts` service.

                Parameters
                ----------
                access_token : builtins.str, optional
                    The access token for Vercel.
                endpoint : builtins.str, optional
                    The endpoint for the Vercel artifacts API.
                    Defaults to `https://api.vercel.com`.
                team_id : builtins.str, optional
                    The Vercel team ID.
                    When set, the `teamId` query parameter is appended
                    to all API requests.
                team_slug : builtins.str, optional
                    The Vercel team slug.
                    When set, the `slug` query parameter is appended to
                    all API requests.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `vercel-artifacts` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.VercelBlob, "vercel-blob"],
                /,
                *,
                root: builtins.str = ...,
                token: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `vercel-blob` service.

                Parameters
                ----------
                root : builtins.str, optional
                    root of this backend.
                    All operations will happen under this root.
                token : builtins.str, optional
                    vercel blob token.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `vercel-blob` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Webdav, "webdav"],
                /,
                *,
                disable_copy: builtins.bool = ...,
                disable_create_dir: builtins.bool = ...,
                enable_user_metadata: builtins.bool = ...,
                endpoint: builtins.str = ...,
                password: builtins.str = ...,
                root: builtins.str = ...,
                token: builtins.str = ...,
                user_metadata_prefix: builtins.str = ...,
                user_metadata_uri: builtins.str = ...,
                username: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `webdav` service.

                Parameters
                ----------
                disable_copy : builtins.bool, optional
                    Deprecated: WebDAV copy capability is enabled by
                    default.
                disable_create_dir : builtins.bool, optional
                    Disable automatic parent directory creation before
                    write operations.
                    By default, OpenDAL creates parent directories using
                    MKCOL before writing files.
                    This requires PROPFIND support to check directory
                    existence.
                    Some WebDAV-compatible servers (e.g., bazel-remote)
                    don't support PROPFIND or don't require explicit
                    directory creation.
                    Enable this option to skip the MKCOL calls and write
                    files directly.
                    Default: false
                enable_user_metadata : builtins.bool, optional
                    Deprecated: WebDAV user metadata capability is
                    enabled by default.
                endpoint : builtins.str, optional
                    endpoint of this backend
                password : builtins.str, optional
                    password of this backend
                root : builtins.str, optional
                    root of this backend
                token : builtins.str, optional
                    token of this backend
                user_metadata_prefix : builtins.str, optional
                    The XML namespace prefix for user metadata
                    properties.
                    This prefix is used in PROPPATCH/PROPFIND XML
                    requests.
                    Different servers may require different prefixes.
                    Default: "opendal"
                user_metadata_uri : builtins.str, optional
                    The XML namespace URI for user metadata properties.
                    This URI uniquely identifies the namespace for
                    custom properties.
                    Different servers may require different namespace
                    URIs.
                    For example, Nextcloud might work better with its
                    own namespace.
                    Default: `https://opendal.apache.org/ns`
                username : builtins.str, optional
                    username of this backend
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `webdav` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.Webhdfs, "webhdfs"],
                /,
                *,
                atomic_write_dir: builtins.str = ...,
                delegation: builtins.str = ...,
                disable_list_batch: builtins.bool = ...,
                endpoint: builtins.str = ...,
                root: builtins.str = ...,
                user_name: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `webhdfs` service.

                Parameters
                ----------
                atomic_write_dir : builtins.str, optional
                    atomic_write_dir of this backend
                delegation : builtins.str, optional
                    Delegation token for webhdfs.
                disable_list_batch : builtins.bool, optional
                    Disable batch listing
                endpoint : builtins.str, optional
                    Endpoint for webhdfs.
                root : builtins.str, optional
                    Root for webhdfs.
                user_name : builtins.str, optional
                    Name of the user for webhdfs.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `webhdfs` service
                """
        "#
    }
}

submit! {
    gen_methods_from_python! {
        r#"
        import builtins
        import typing
        import opendal.services
        class AsyncOperator:
            @overload
            def __new__(cls,
                scheme: typing.Literal[opendal.services.Scheme.YandexDisk, "yandex-disk"],
                /,
                *,
                access_token: builtins.str,
                root: builtins.str = ...,
            ) -> typing.Self:
                r"""
                Create a new `AsyncOperator` for `yandex-disk` service.

                Parameters
                ----------
                access_token : builtins.str
                    yandex disk oauth access_token.
                root : builtins.str, optional
                    root of this backend.
                    All operations will happen under this root.
                Returns
                -------
                AsyncOperator
                    The new `AsyncOperator` for `yandex-disk` service
                """
        "#
    }
}

macro_rules! impl_enum_to_str {
    ($src:ty { $(
        $(#[$cfg:meta])?
        $variant:ident => $value:literal
    ),* $(,)? }) => {
        impl From<$src> for &'static str {
            fn from(value: $src) -> Self {
                match value {
                    $(
                        $(#[$cfg])?
                        <$src>::$variant => $value,
                    )*
                }
            }
        }

        impl From<$src> for String {
            fn from(value: $src) -> Self {
                let v: &'static str = value.into();
                v.to_string()
            }
        }
    };
}

impl_enum_to_str!(
    PyScheme {
        #[cfg(feature = "services-aliyun-drive")]
        AliyunDrive => "aliyun-drive",
        #[cfg(feature = "services-alluxio")]
        Alluxio => "alluxio",
        #[cfg(feature = "services-azblob")]
        Azblob => "azblob",
        #[cfg(feature = "services-azdls")]
        Azdls => "azdls",
        #[cfg(feature = "services-azfile")]
        Azfile => "azfile",
        #[cfg(feature = "services-b2")]
        B2 => "b2",
        #[cfg(feature = "services-cacache")]
        Cacache => "cacache",
        #[cfg(feature = "services-cloudflare-kv")]
        CloudflareKv => "cloudflare-kv",
        #[cfg(feature = "services-cos")]
        Cos => "cos",
        #[cfg(feature = "services-dashmap")]
        Dashmap => "dashmap",
        #[cfg(feature = "services-dropbox")]
        Dropbox => "dropbox",
        #[cfg(feature = "services-fs")]
        Fs => "fs",
        #[cfg(feature = "services-ftp")]
        Ftp => "ftp",
        #[cfg(feature = "services-gcs")]
        Gcs => "gcs",
        #[cfg(feature = "services-gdrive")]
        Gdrive => "gdrive",
        #[cfg(feature = "services-ghac")]
        Ghac => "ghac",
        #[cfg(feature = "services-goosefs")]
        Goosefs => "goosefs",
        #[cfg(feature = "services-gridfs")]
        Gridfs => "gridfs",
        #[cfg(feature = "services-hdfs-native")]
        HdfsNative => "hdfs-native",
        #[cfg(feature = "services-hf")]
        Hf => "hf",
        #[cfg(feature = "services-http")]
        Http => "http",
        #[cfg(feature = "services-ipfs")]
        Ipfs => "ipfs",
        #[cfg(feature = "services-ipmfs")]
        Ipmfs => "ipmfs",
        #[cfg(feature = "services-koofr")]
        Koofr => "koofr",
        #[cfg(feature = "services-memcached")]
        Memcached => "memcached",
        #[cfg(feature = "services-memory")]
        Memory => "memory",
        #[cfg(feature = "services-mini-moka")]
        MiniMoka => "mini-moka",
        #[cfg(feature = "services-moka")]
        Moka => "moka",
        #[cfg(feature = "services-mongodb")]
        Mongodb => "mongodb",
        #[cfg(feature = "services-mysql")]
        Mysql => "mysql",
        #[cfg(feature = "services-obs")]
        Obs => "obs",
        #[cfg(feature = "services-onedrive")]
        Onedrive => "onedrive",
        #[cfg(feature = "services-oss")]
        Oss => "oss",
        #[cfg(feature = "services-persy")]
        Persy => "persy",
        #[cfg(feature = "services-postgresql")]
        Postgresql => "postgresql",
        #[cfg(feature = "services-redb")]
        Redb => "redb",
        #[cfg(feature = "services-redis")]
        Redis => "redis",
        #[cfg(feature = "services-s3")]
        S3 => "s3",
        #[cfg(feature = "services-seafile")]
        Seafile => "seafile",
        #[cfg(feature = "services-sftp")]
        Sftp => "sftp",
        #[cfg(feature = "services-sled")]
        Sled => "sled",
        #[cfg(feature = "services-sqlite")]
        Sqlite => "sqlite",
        #[cfg(feature = "services-swift")]
        Swift => "swift",
        #[cfg(feature = "services-tos")]
        Tos => "tos",
        #[cfg(feature = "services-upyun")]
        Upyun => "upyun",
        #[cfg(feature = "services-vercel-artifacts")]
        VercelArtifacts => "vercel-artifacts",
        #[cfg(feature = "services-vercel-blob")]
        VercelBlob => "vercel-blob",
        #[cfg(feature = "services-webdav")]
        Webdav => "webdav",
        #[cfg(feature = "services-webhdfs")]
        Webhdfs => "webhdfs",
        #[cfg(feature = "services-yandex-disk")]
        YandexDisk => "yandex-disk",
    }
);
