1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351


//! Update an organization
//! 
//! **Parameter Deprecation Notice:** GitHub will replace and discontinue `members_allowed_repository_creation_type` in favor of more granular permissions. The new input parameters are `members_can_create_public_repositories`, `members_can_create_private_repositories` for all organizations and `members_can_create_internal_repositories` for organizations associated with an enterprise account using GitHub Enterprise Cloud or GitHub Enterprise Server 2.20+. For more information, see the [blog post](https://developer.github.com/changes/2019-12-03-internal-visibility-changes).
//! 
//! Enables an authenticated organization owner with the `admin:org` scope to update the organization's profile and member privileges.
//! 
//! [API method documentation](https://docs.github.com/rest/reference/orgs/#update-an-organization)

pub struct Content<Body>
{
    body: Body,
    content_type_value: Option<::std::borrow::Cow<'static, [u8]>>,
}

impl<Body> Content<Body> {
    pub fn new(body: Body) -> Self {
        Self { body, content_type_value: None }
    }

    #[must_use]
    pub fn with_content_type(mut self, content_type: impl Into<::std::borrow::Cow<'static, [u8]>>) -> Self {
        self.content_type_value = Some(content_type.into());
        self
    }

    fn content_type(&self) -> Option<&[u8]> {
        self.content_type_value.as_deref()
    }

    fn into_body(self) -> Body {
        self.body
    }
}

fn url_string(
    base_url: &str,
    p_org: &str,
) -> Result<String, crate::v1_1_4::ApiError> {
    let trimmed = if base_url.is_empty() {
        "https://api.github.com"
    } else {
        base_url.trim_end_matches('/')
    };
    let mut url = String::with_capacity(trimmed.len() + 23);
    url.push_str(trimmed);
    url.push_str("/orgs/");
    ::querylizer::Simple::extend(&mut url, &p_org, false, &::querylizer::encode_path)?;
    Ok(url)
}

#[cfg(feature = "hyper")]
pub fn http_builder(
    base_url: &str,
    p_org: &str,
    h_user_agent: &str,
    h_accept: ::std::option::Option<&str>,
) -> Result<::http::request::Builder, crate::v1_1_4::ApiError> {
    let url = url_string(
        base_url,
        p_org,
    )?;
    let mut builder = ::http::request::Request::patch(url);
    builder = builder.header(
        "User-Agent",
        &::querylizer::Simple::to_string(&h_user_agent, false, &::querylizer::passthrough)?
    );
    if let Some(value) = &h_accept {
        builder = builder.header(
            "Accept",
            &::querylizer::Simple::to_string(value, false, &::querylizer::passthrough)?
        );
    }
    Ok(builder)
}

#[cfg(feature = "hyper")]
pub fn hyper_request(
    mut builder: ::http::request::Builder,
    content: Content<::hyper::Body>,
) -> Result<::http::request::Request<::hyper::Body>, crate::v1_1_4::ApiError>
{
    if let Some(content_type) = content.content_type() {
        builder = builder.header(::http::header::CONTENT_TYPE, content_type);
    }
    Ok(builder.body(content.into_body())?)
}

#[cfg(feature = "hyper")]
impl From<::hyper::Body> for Content<::hyper::Body> {
    fn from(body: ::hyper::Body) -> Self {
        Self::new(body)
    }
}

#[cfg(feature = "reqwest")]
pub fn reqwest_builder(
    base_url: &str,
    p_org: &str,
    h_user_agent: &str,
    h_accept: ::std::option::Option<&str>,
) -> Result<::reqwest::Request, crate::v1_1_4::ApiError> {
    let url = url_string(
        base_url,
        p_org,
    )?;
    let reqwest_url = ::reqwest::Url::parse(&url)?;
    let mut request = ::reqwest::Request::new(::reqwest::Method::PATCH, reqwest_url);
    let headers = request.headers_mut();
    headers.append(
        "User-Agent",
        ::querylizer::Simple::to_string(&h_user_agent, false, &::querylizer::passthrough)?.try_into()?
    );
    if let Some(value) = &h_accept {
        headers.append(
            "Accept",
            ::querylizer::Simple::to_string(value, false, &::querylizer::passthrough)?.try_into()?
        );
    }
    Ok(request)
}

#[cfg(feature = "reqwest")]
pub fn reqwest_request(
    mut builder: ::reqwest::Request,
    content: Content<::reqwest::Body>,
) -> Result<::reqwest::Request, crate::v1_1_4::ApiError> {
    if let Some(content_type) = content.content_type() {
        builder.headers_mut().append(
            ::reqwest::header::HeaderName::from_static("content-type"),
            ::reqwest::header::HeaderValue::try_from(content_type)?,
        );
    }
    *builder.body_mut() = Some(content.into_body());
    Ok(builder)
}

#[cfg(feature = "reqwest")]
impl From<::reqwest::Body> for Content<::reqwest::Body> {
    fn from(body: ::reqwest::Body) -> Self {
        Self::new(body)
    }
}

#[cfg(feature = "reqwest-blocking")]
pub fn reqwest_blocking_builder(
    base_url: &str,
    p_org: &str,
    h_user_agent: &str,
    h_accept: ::std::option::Option<&str>,
) -> Result<::reqwest::blocking::Request, crate::v1_1_4::ApiError> {
    let url = url_string(
        base_url,
        p_org,
    )?;
    let reqwest_url = ::reqwest::Url::parse(&url)?;
    let mut request = ::reqwest::blocking::Request::new(::reqwest::Method::PATCH, reqwest_url);
    let headers = request.headers_mut();
    headers.append(
        "User-Agent",
        ::querylizer::Simple::to_string(&h_user_agent, false, &::querylizer::passthrough)?.try_into()?
    );
    if let Some(value) = &h_accept {
        headers.append(
            "Accept",
            ::querylizer::Simple::to_string(value, false, &::querylizer::passthrough)?.try_into()?
        );
    }
    Ok(request)
}

#[cfg(feature = "reqwest-blocking")]
pub fn reqwest_blocking_request(
    mut builder: ::reqwest::blocking::Request,
    content: Content<::reqwest::blocking::Body>,
) -> Result<::reqwest::blocking::Request, crate::v1_1_4::ApiError> {
    if let Some(content_type) = content.content_type() {
        builder.headers_mut().append(
            ::reqwest::header::HeaderName::from_static("content-type"),
            ::reqwest::header::HeaderValue::try_from(content_type)?,
        );
    }
    *builder.body_mut() = Some(content.into_body());
    Ok(builder)
}

#[cfg(feature = "reqwest-blocking")]
impl From<::reqwest::blocking::Body> for Content<::reqwest::blocking::Body> {
    fn from(body: ::reqwest::blocking::Body) -> Self {
        Self::new(body)
    }
}

#[cfg(feature = "hyper")]
impl<'a> TryFrom<&crate::v1_1_4::request::orgs_update::body::Json<'a>> for Content<::hyper::Body> {
    type Error = crate::v1_1_4::ApiError;

    fn try_from(value: &crate::v1_1_4::request::orgs_update::body::Json<'a>) -> Result<Self, Self::Error> {
        Ok(
            Self::new(::serde_json::to_vec(value)?.into())
            .with_content_type(&b"application/json"[..])
        )
    }
}

#[cfg(feature = "reqwest")]
impl<'a> TryFrom<&crate::v1_1_4::request::orgs_update::body::Json<'a>> for Content<::reqwest::Body> {
    type Error = crate::v1_1_4::ApiError;

    fn try_from(value: &crate::v1_1_4::request::orgs_update::body::Json<'a>) -> Result<Self, Self::Error> {
        Ok(
            Self::new(::serde_json::to_vec(value)?.into())
            .with_content_type(&b"application/json"[..])
        )
    }
}

#[cfg(feature = "reqwest-blocking")]
impl<'a> TryFrom<&crate::v1_1_4::request::orgs_update::body::Json<'a>> for Content<::reqwest::blocking::Body> {
    type Error = crate::v1_1_4::ApiError;

    fn try_from(value: &crate::v1_1_4::request::orgs_update::body::Json<'a>) -> Result<Self, Self::Error> {
        Ok(
            Self::new(::serde_json::to_vec(value)?.into())
            .with_content_type(&b"application/json"[..])
        )
    }
}

/// Types for body parameter in [`super::orgs_update`]
pub mod body {
    #[allow(non_snake_case)]
    #[derive(Clone, Eq, PartialEq, Debug, Default, ::serde::Serialize, ::serde::Deserialize)]
    pub struct Json<'a> {
        /// Billing email address. This address is not publicized.
        #[serde(skip_serializing_if = "Option::is_none", default)]
        pub billing_email: ::std::option::Option<::std::borrow::Cow<'a, str>>,

        /// The company name.
        #[serde(skip_serializing_if = "Option::is_none", default)]
        pub company: ::std::option::Option<::std::borrow::Cow<'a, str>>,

        /// The publicly visible email address.
        #[serde(skip_serializing_if = "Option::is_none", default)]
        pub email: ::std::option::Option<::std::borrow::Cow<'a, str>>,

        /// The Twitter username of the company.
        #[serde(skip_serializing_if = "Option::is_none", default)]
        pub twitter_username: ::std::option::Option<::std::borrow::Cow<'a, str>>,

        /// The location.
        #[serde(skip_serializing_if = "Option::is_none", default)]
        pub location: ::std::option::Option<::std::borrow::Cow<'a, str>>,

        /// The shorthand name of the company.
        #[serde(skip_serializing_if = "Option::is_none", default)]
        pub name: ::std::option::Option<::std::borrow::Cow<'a, str>>,

        /// The description of the company.
        #[serde(skip_serializing_if = "Option::is_none", default)]
        pub description: ::std::option::Option<::std::borrow::Cow<'a, str>>,

        /// Toggles whether an organization can use organization projects.
        #[serde(skip_serializing_if = "Option::is_none", default)]
        pub has_organization_projects: ::std::option::Option<bool>,

        /// Toggles whether repositories that belong to the organization can use repository projects.
        #[serde(skip_serializing_if = "Option::is_none", default)]
        pub has_repository_projects: ::std::option::Option<bool>,

        /// Default permission level members have for organization repositories:  
        /// \* `read` - can pull, but not push to or administer this repository.  
        /// \* `write` - can pull and push, but not administer this repository.  
        /// \* `admin` - can pull, push, and administer this repository.  
        /// \* `none` - no permissions granted by default.
        #[serde(skip_serializing_if = "Option::is_none", default)]
        pub default_repository_permission: ::std::option::Option<::std::borrow::Cow<'a, str>>,

        /// Toggles the ability of non-admin organization members to create repositories. Can be one of:  
        /// \* `true` - all organization members can create repositories.  
        /// \* `false` - only organization owners can create repositories.  
        /// Default: `true`  
        /// **Note:** A parameter can override this parameter. See `members_allowed_repository_creation_type` in this table for details. **Note:** A parameter can override this parameter. See `members_allowed_repository_creation_type` in this table for details.
        #[serde(skip_serializing_if = "Option::is_none", default)]
        pub members_can_create_repositories: ::std::option::Option<bool>,

        /// Toggles whether organization members can create internal repositories, which are visible to all enterprise members. You can only allow members to create internal repositories if your organization is associated with an enterprise account using GitHub Enterprise Cloud or GitHub Enterprise Server 2.20+. Can be one of:  
        /// \* `true` - all organization members can create internal repositories.  
        /// \* `false` - only organization owners can create internal repositories.  
        /// Default: `true`. For more information, see "[Restricting repository creation in your organization](https://docs.github.com/github/setting-up-and-managing-organizations-and-teams/restricting-repository-creation-in-your-organization)" in the GitHub Help documentation.
        #[serde(skip_serializing_if = "Option::is_none", default)]
        pub members_can_create_internal_repositories: ::std::option::Option<bool>,

        /// Toggles whether organization members can create private repositories, which are visible to organization members with permission. Can be one of:  
        /// \* `true` - all organization members can create private repositories.  
        /// \* `false` - only organization owners can create private repositories.  
        /// Default: `true`. For more information, see "[Restricting repository creation in your organization](https://docs.github.com/github/setting-up-and-managing-organizations-and-teams/restricting-repository-creation-in-your-organization)" in the GitHub Help documentation.
        #[serde(skip_serializing_if = "Option::is_none", default)]
        pub members_can_create_private_repositories: ::std::option::Option<bool>,

        /// Toggles whether organization members can create public repositories, which are visible to anyone. Can be one of:  
        /// \* `true` - all organization members can create public repositories.  
        /// \* `false` - only organization owners can create public repositories.  
        /// Default: `true`. For more information, see "[Restricting repository creation in your organization](https://docs.github.com/github/setting-up-and-managing-organizations-and-teams/restricting-repository-creation-in-your-organization)" in the GitHub Help documentation.
        #[serde(skip_serializing_if = "Option::is_none", default)]
        pub members_can_create_public_repositories: ::std::option::Option<bool>,

        /// Specifies which types of repositories non-admin organization members can create. Can be one of:  
        /// \* `all` - all organization members can create public and private repositories.  
        /// \* `private` - members can create private repositories. This option is only available to repositories that are part of an organization on GitHub Enterprise Cloud.  
        /// \* `none` - only admin members can create repositories.  
        /// **Note:** This parameter is deprecated and will be removed in the future. Its return value ignores internal repositories. Using this parameter overrides values set in `members_can_create_repositories`. See the parameter deprecation notice in the operation description for details.
        #[serde(skip_serializing_if = "Option::is_none", default)]
        pub members_allowed_repository_creation_type: ::std::option::Option<::std::borrow::Cow<'a, str>>,

        /// Toggles whether organization members can create GitHub Pages sites. Can be one of:  
        /// \* `true` - all organization members can create GitHub Pages sites.  
        /// \* `false` - no organization members can create GitHub Pages sites. Existing published sites will not be impacted.
        #[serde(skip_serializing_if = "Option::is_none", default)]
        pub members_can_create_pages: ::std::option::Option<bool>,

        /// Toggles whether organization members can create public GitHub Pages sites. Can be one of:  
        /// \* `true` - all organization members can create public GitHub Pages sites.  
        /// \* `false` - no organization members can create public GitHub Pages sites. Existing published sites will not be impacted.
        #[serde(skip_serializing_if = "Option::is_none", default)]
        pub members_can_create_public_pages: ::std::option::Option<bool>,

        /// Toggles whether organization members can create private GitHub Pages sites. Can be one of:  
        /// \* `true` - all organization members can create private GitHub Pages sites.  
        /// \* `false` - no organization members can create private GitHub Pages sites. Existing published sites will not be impacted.
        #[serde(skip_serializing_if = "Option::is_none", default)]
        pub members_can_create_private_pages: ::std::option::Option<bool>,

        /// Toggles whether organization members can fork private organization repositories. Can be one of:  
        /// \* `true` - all organization members can fork private repositories within the organization.  
        /// \* `false` - no organization members can fork private repositories within the organization.
        #[serde(skip_serializing_if = "Option::is_none", default)]
        pub members_can_fork_private_repositories: ::std::option::Option<bool>,

        /// # Example
        /// 
        /// ```json
        /// "\"http://github.blog\""
        /// ```
        #[serde(skip_serializing_if = "Option::is_none", default)]
        pub blog: ::std::option::Option<::std::borrow::Cow<'a, str>>,

        #[serde(flatten)]
        pub additionalProperties: ::std::collections::HashMap<::std::borrow::Cow<'a, str>, ::serde_json::value::Value>
    }
}