diff --git a/src/GitHub/Models/CodeScanningDefaultSetupUpdate_languages.cs b/src/GitHub/Models/CodeScanningDefaultSetupUpdate_languages.cs index 08f48423..9d115c0f 100644 --- a/src/GitHub/Models/CodeScanningDefaultSetupUpdate_languages.cs +++ b/src/GitHub/Models/CodeScanningDefaultSetupUpdate_languages.cs @@ -8,6 +8,10 @@ namespace GitHub.Models public enum CodeScanningDefaultSetupUpdate_languages #pragma warning restore CS1591 { + [EnumMember(Value = "actions")] + #pragma warning disable CS1591 + Actions, + #pragma warning restore CS1591 [EnumMember(Value = "c-cpp")] #pragma warning disable CS1591 CCpp, diff --git a/src/GitHub/Models/CodeScanningDefaultSetup_languages.cs b/src/GitHub/Models/CodeScanningDefaultSetup_languages.cs index 73a4c0e5..3ed2a15d 100644 --- a/src/GitHub/Models/CodeScanningDefaultSetup_languages.cs +++ b/src/GitHub/Models/CodeScanningDefaultSetup_languages.cs @@ -8,6 +8,10 @@ namespace GitHub.Models public enum CodeScanningDefaultSetup_languages #pragma warning restore CS1591 { + [EnumMember(Value = "actions")] + #pragma warning disable CS1591 + Actions, + #pragma warning restore CS1591 [EnumMember(Value = "c-cpp")] #pragma warning disable CS1591 CCpp, diff --git a/src/GitHub/Models/OrgPrivateRegistryConfiguration.cs b/src/GitHub/Models/OrgPrivateRegistryConfiguration.cs new file mode 100644 index 00000000..5f52ddfd --- /dev/null +++ b/src/GitHub/Models/OrgPrivateRegistryConfiguration.cs @@ -0,0 +1,92 @@ +// +#pragma warning disable CS0618 +using Microsoft.Kiota.Abstractions.Extensions; +using Microsoft.Kiota.Abstractions.Serialization; +using System.Collections.Generic; +using System.IO; +using System; +namespace GitHub.Models +{ + /// + /// Private registry configuration for an organization + /// + [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.19.0")] + public partial class OrgPrivateRegistryConfiguration : IAdditionalDataHolder, IParsable + { + /// Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. + public IDictionary AdditionalData { get; set; } + /// The created_at property + public DateTimeOffset? CreatedAt { get; set; } + /// The name of the private registry configuration. +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Name { get; set; } +#nullable restore +#else + public string Name { get; set; } +#endif + /// The registry type. + public global::GitHub.Models.OrgPrivateRegistryConfiguration_registry_type? RegistryType { get; set; } + /// The updated_at property + public DateTimeOffset? UpdatedAt { get; set; } + /// The username to use when authenticating with the private registry. +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Username { get; set; } +#nullable restore +#else + public string Username { get; set; } +#endif + /// Which type of organization repositories have access to the private registry. + public global::GitHub.Models.OrgPrivateRegistryConfiguration_visibility? Visibility { get; set; } + /// + /// Instantiates a new and sets the default values. + /// + public OrgPrivateRegistryConfiguration() + { + AdditionalData = new Dictionary(); + } + /// + /// Creates a new instance of the appropriate class based on discriminator value + /// + /// A + /// The parse node to use to read the discriminator value and create the object + public static global::GitHub.Models.OrgPrivateRegistryConfiguration CreateFromDiscriminatorValue(IParseNode parseNode) + { + _ = parseNode ?? throw new ArgumentNullException(nameof(parseNode)); + return new global::GitHub.Models.OrgPrivateRegistryConfiguration(); + } + /// + /// The deserialization information for the current model + /// + /// A IDictionary<string, Action<IParseNode>> + public virtual IDictionary> GetFieldDeserializers() + { + return new Dictionary> + { + { "created_at", n => { CreatedAt = n.GetDateTimeOffsetValue(); } }, + { "name", n => { Name = n.GetStringValue(); } }, + { "registry_type", n => { RegistryType = n.GetEnumValue(); } }, + { "updated_at", n => { UpdatedAt = n.GetDateTimeOffsetValue(); } }, + { "username", n => { Username = n.GetStringValue(); } }, + { "visibility", n => { Visibility = n.GetEnumValue(); } }, + }; + } + /// + /// Serializes information the current object + /// + /// Serialization writer to use to serialize this model + public virtual void Serialize(ISerializationWriter writer) + { + _ = writer ?? throw new ArgumentNullException(nameof(writer)); + writer.WriteDateTimeOffsetValue("created_at", CreatedAt); + writer.WriteStringValue("name", Name); + writer.WriteEnumValue("registry_type", RegistryType); + writer.WriteDateTimeOffsetValue("updated_at", UpdatedAt); + writer.WriteStringValue("username", Username); + writer.WriteEnumValue("visibility", Visibility); + writer.WriteAdditionalData(AdditionalData); + } + } +} +#pragma warning restore CS0618 diff --git a/src/GitHub/Models/OrgPrivateRegistryConfigurationWithSelectedRepositories.cs b/src/GitHub/Models/OrgPrivateRegistryConfigurationWithSelectedRepositories.cs new file mode 100644 index 00000000..4e8e8e54 --- /dev/null +++ b/src/GitHub/Models/OrgPrivateRegistryConfigurationWithSelectedRepositories.cs @@ -0,0 +1,102 @@ +// +#pragma warning disable CS0618 +using Microsoft.Kiota.Abstractions.Extensions; +using Microsoft.Kiota.Abstractions.Serialization; +using System.Collections.Generic; +using System.IO; +using System; +namespace GitHub.Models +{ + /// + /// Private registry configuration for an organization + /// + [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.19.0")] + public partial class OrgPrivateRegistryConfigurationWithSelectedRepositories : IAdditionalDataHolder, IParsable + { + /// Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. + public IDictionary AdditionalData { get; set; } + /// The created_at property + public DateTimeOffset? CreatedAt { get; set; } + /// The name of the private registry configuration. +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Name { get; set; } +#nullable restore +#else + public string Name { get; set; } +#endif + /// The registry type. + public global::GitHub.Models.OrgPrivateRegistryConfigurationWithSelectedRepositories_registry_type? RegistryType { get; set; } + /// An array of repository IDs that can access the organization private registry when `visibility` is set to `selected`. +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public List? SelectedRepositoryIds { get; set; } +#nullable restore +#else + public List SelectedRepositoryIds { get; set; } +#endif + /// The updated_at property + public DateTimeOffset? UpdatedAt { get; set; } + /// The username to use when authenticating with the private registry. +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Username { get; set; } +#nullable restore +#else + public string Username { get; set; } +#endif + /// Which type of organization repositories have access to the private registry. `selected` means only the repositories specified by `selected_repository_ids` can access the private registry. + public global::GitHub.Models.OrgPrivateRegistryConfigurationWithSelectedRepositories_visibility? Visibility { get; set; } + /// + /// Instantiates a new and sets the default values. + /// + public OrgPrivateRegistryConfigurationWithSelectedRepositories() + { + AdditionalData = new Dictionary(); + } + /// + /// Creates a new instance of the appropriate class based on discriminator value + /// + /// A + /// The parse node to use to read the discriminator value and create the object + public static global::GitHub.Models.OrgPrivateRegistryConfigurationWithSelectedRepositories CreateFromDiscriminatorValue(IParseNode parseNode) + { + _ = parseNode ?? throw new ArgumentNullException(nameof(parseNode)); + return new global::GitHub.Models.OrgPrivateRegistryConfigurationWithSelectedRepositories(); + } + /// + /// The deserialization information for the current model + /// + /// A IDictionary<string, Action<IParseNode>> + public virtual IDictionary> GetFieldDeserializers() + { + return new Dictionary> + { + { "created_at", n => { CreatedAt = n.GetDateTimeOffsetValue(); } }, + { "name", n => { Name = n.GetStringValue(); } }, + { "registry_type", n => { RegistryType = n.GetEnumValue(); } }, + { "selected_repository_ids", n => { SelectedRepositoryIds = n.GetCollectionOfPrimitiveValues()?.AsList(); } }, + { "updated_at", n => { UpdatedAt = n.GetDateTimeOffsetValue(); } }, + { "username", n => { Username = n.GetStringValue(); } }, + { "visibility", n => { Visibility = n.GetEnumValue(); } }, + }; + } + /// + /// Serializes information the current object + /// + /// Serialization writer to use to serialize this model + public virtual void Serialize(ISerializationWriter writer) + { + _ = writer ?? throw new ArgumentNullException(nameof(writer)); + writer.WriteDateTimeOffsetValue("created_at", CreatedAt); + writer.WriteStringValue("name", Name); + writer.WriteEnumValue("registry_type", RegistryType); + writer.WriteCollectionOfPrimitiveValues("selected_repository_ids", SelectedRepositoryIds); + writer.WriteDateTimeOffsetValue("updated_at", UpdatedAt); + writer.WriteStringValue("username", Username); + writer.WriteEnumValue("visibility", Visibility); + writer.WriteAdditionalData(AdditionalData); + } + } +} +#pragma warning restore CS0618 diff --git a/src/GitHub/Models/OrgPrivateRegistryConfigurationWithSelectedRepositories_registry_type.cs b/src/GitHub/Models/OrgPrivateRegistryConfigurationWithSelectedRepositories_registry_type.cs new file mode 100644 index 00000000..1bf441c7 --- /dev/null +++ b/src/GitHub/Models/OrgPrivateRegistryConfigurationWithSelectedRepositories_registry_type.cs @@ -0,0 +1,15 @@ +// +using System.Runtime.Serialization; +using System; +namespace GitHub.Models +{ + /// The registry type. + [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.19.0")] + public enum OrgPrivateRegistryConfigurationWithSelectedRepositories_registry_type + { + [EnumMember(Value = "maven_repository")] + #pragma warning disable CS1591 + Maven_repository, + #pragma warning restore CS1591 + } +} diff --git a/src/GitHub/Models/OrgPrivateRegistryConfigurationWithSelectedRepositories_visibility.cs b/src/GitHub/Models/OrgPrivateRegistryConfigurationWithSelectedRepositories_visibility.cs new file mode 100644 index 00000000..8d182c87 --- /dev/null +++ b/src/GitHub/Models/OrgPrivateRegistryConfigurationWithSelectedRepositories_visibility.cs @@ -0,0 +1,23 @@ +// +using System.Runtime.Serialization; +using System; +namespace GitHub.Models +{ + /// Which type of organization repositories have access to the private registry. `selected` means only the repositories specified by `selected_repository_ids` can access the private registry. + [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.19.0")] + public enum OrgPrivateRegistryConfigurationWithSelectedRepositories_visibility + { + [EnumMember(Value = "all")] + #pragma warning disable CS1591 + All, + #pragma warning restore CS1591 + [EnumMember(Value = "private")] + #pragma warning disable CS1591 + Private, + #pragma warning restore CS1591 + [EnumMember(Value = "selected")] + #pragma warning disable CS1591 + Selected, + #pragma warning restore CS1591 + } +} diff --git a/src/GitHub/Models/OrgPrivateRegistryConfiguration_registry_type.cs b/src/GitHub/Models/OrgPrivateRegistryConfiguration_registry_type.cs new file mode 100644 index 00000000..068314a0 --- /dev/null +++ b/src/GitHub/Models/OrgPrivateRegistryConfiguration_registry_type.cs @@ -0,0 +1,15 @@ +// +using System.Runtime.Serialization; +using System; +namespace GitHub.Models +{ + /// The registry type. + [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.19.0")] + public enum OrgPrivateRegistryConfiguration_registry_type + { + [EnumMember(Value = "maven_repository")] + #pragma warning disable CS1591 + Maven_repository, + #pragma warning restore CS1591 + } +} diff --git a/src/GitHub/Models/OrgPrivateRegistryConfiguration_visibility.cs b/src/GitHub/Models/OrgPrivateRegistryConfiguration_visibility.cs new file mode 100644 index 00000000..6e3c7e6a --- /dev/null +++ b/src/GitHub/Models/OrgPrivateRegistryConfiguration_visibility.cs @@ -0,0 +1,23 @@ +// +using System.Runtime.Serialization; +using System; +namespace GitHub.Models +{ + /// Which type of organization repositories have access to the private registry. + [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.19.0")] + public enum OrgPrivateRegistryConfiguration_visibility + { + [EnumMember(Value = "all")] + #pragma warning disable CS1591 + All, + #pragma warning restore CS1591 + [EnumMember(Value = "private")] + #pragma warning disable CS1591 + Private, + #pragma warning restore CS1591 + [EnumMember(Value = "selected")] + #pragma warning disable CS1591 + Selected, + #pragma warning restore CS1591 + } +} diff --git a/src/GitHub/Models/Users.cs b/src/GitHub/Models/Users.cs index ee1970b9..1353411f 100644 --- a/src/GitHub/Models/Users.cs +++ b/src/GitHub/Models/Users.cs @@ -14,45 +14,23 @@ public partial class Users : IAdditionalDataHolder, IParsable { /// Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. public IDictionary AdditionalData { get; set; } - /// The fragment property + /// Whether this email address is the primary address. + public bool? Primary { get; set; } + /// The type of email address. #if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER #nullable enable - public string? Fragment { get; set; } + public string? Type { get; set; } #nullable restore #else - public string Fragment { get; set; } + public string Type { get; set; } #endif - /// The matches property + /// The email address. #if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER #nullable enable - public List? Matches { get; set; } + public string? Value { get; set; } #nullable restore #else - public List Matches { get; set; } -#endif - /// The object_type property -#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER -#nullable enable - public string? ObjectType { get; set; } -#nullable restore -#else - public string ObjectType { get; set; } -#endif - /// The object_url property -#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER -#nullable enable - public string? ObjectUrl { get; set; } -#nullable restore -#else - public string ObjectUrl { get; set; } -#endif - /// The property property -#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER -#nullable enable - public string? Property { get; set; } -#nullable restore -#else - public string Property { get; set; } + public string Value { get; set; } #endif /// /// Instantiates a new and sets the default values. @@ -79,11 +57,9 @@ public virtual IDictionary> GetFieldDeserializers() { return new Dictionary> { - { "fragment", n => { Fragment = n.GetStringValue(); } }, - { "matches", n => { Matches = n.GetCollectionOfObjectValues(global::GitHub.Models.Users_matches.CreateFromDiscriminatorValue)?.AsList(); } }, - { "object_type", n => { ObjectType = n.GetStringValue(); } }, - { "object_url", n => { ObjectUrl = n.GetStringValue(); } }, - { "property", n => { Property = n.GetStringValue(); } }, + { "primary", n => { Primary = n.GetBoolValue(); } }, + { "type", n => { Type = n.GetStringValue(); } }, + { "value", n => { Value = n.GetStringValue(); } }, }; } /// @@ -93,11 +69,9 @@ public virtual IDictionary> GetFieldDeserializers() public virtual void Serialize(ISerializationWriter writer) { _ = writer ?? throw new ArgumentNullException(nameof(writer)); - writer.WriteStringValue("fragment", Fragment); - writer.WriteCollectionOfObjectValues("matches", Matches); - writer.WriteStringValue("object_type", ObjectType); - writer.WriteStringValue("object_url", ObjectUrl); - writer.WriteStringValue("property", Property); + writer.WriteBoolValue("primary", Primary); + writer.WriteStringValue("type", Type); + writer.WriteStringValue("value", Value); writer.WriteAdditionalData(AdditionalData); } } diff --git a/src/GitHub/Orgs/Item/PrivateRegistries/Item/WithSecret_nameItemRequestBuilder.cs b/src/GitHub/Orgs/Item/PrivateRegistries/Item/WithSecret_nameItemRequestBuilder.cs new file mode 100644 index 00000000..45d7cb94 --- /dev/null +++ b/src/GitHub/Orgs/Item/PrivateRegistries/Item/WithSecret_nameItemRequestBuilder.cs @@ -0,0 +1,183 @@ +// +#pragma warning disable CS0618 +using GitHub.Models; +using Microsoft.Kiota.Abstractions.Extensions; +using Microsoft.Kiota.Abstractions.Serialization; +using Microsoft.Kiota.Abstractions; +using System.Collections.Generic; +using System.IO; +using System.Threading.Tasks; +using System.Threading; +using System; +namespace GitHub.Orgs.Item.PrivateRegistries.Item +{ + /// + /// Builds and executes requests for operations under \orgs\{org}\private-registries\{secret_name} + /// + [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.19.0")] + public partial class WithSecret_nameItemRequestBuilder : BaseRequestBuilder + { + /// + /// Instantiates a new and sets the default values. + /// + /// Path parameters for the request + /// The request adapter to use to execute the requests. + public WithSecret_nameItemRequestBuilder(Dictionary pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/orgs/{org}/private-registries/{secret_name}", pathParameters) + { + } + /// + /// Instantiates a new and sets the default values. + /// + /// The raw URL to use for the request builder. + /// The request adapter to use to execute the requests. + public WithSecret_nameItemRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/orgs/{org}/private-registries/{secret_name}", rawUrl) + { + } + /// + /// > [!NOTE]> This endpoint is in public preview and is subject to change.Delete a private registry configuration at the organization-level.OAuth app tokens and personal access tokens (classic) need the `admin:org` scope to use this endpoint. + /// API method documentation + /// + /// Cancellation token to use when cancelling requests + /// Configuration for the request such as headers, query parameters, and middleware options. + /// When receiving a 400 status code + /// When receiving a 404 status code +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public async Task DeleteAsync(Action>? requestConfiguration = default, CancellationToken cancellationToken = default) + { +#nullable restore +#else + public async Task DeleteAsync(Action> requestConfiguration = default, CancellationToken cancellationToken = default) + { +#endif + var requestInfo = ToDeleteRequestInformation(requestConfiguration); + var errorMapping = new Dictionary> + { + { "400", global::GitHub.Models.BasicError.CreateFromDiscriminatorValue }, + { "404", global::GitHub.Models.BasicError.CreateFromDiscriminatorValue }, + }; + await RequestAdapter.SendNoContentAsync(requestInfo, errorMapping, cancellationToken).ConfigureAwait(false); + } + /// + /// > [!NOTE]> This endpoint is in public preview and is subject to change.Get the configuration of a single private registry defined for an organization, omitting its encrypted value.OAuth app tokens and personal access tokens (classic) need the `admin:org` scope to use this endpoint. + /// API method documentation + /// + /// A + /// Cancellation token to use when cancelling requests + /// Configuration for the request such as headers, query parameters, and middleware options. + /// When receiving a 404 status code +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public async Task GetAsync(Action>? requestConfiguration = default, CancellationToken cancellationToken = default) + { +#nullable restore +#else + public async Task GetAsync(Action> requestConfiguration = default, CancellationToken cancellationToken = default) + { +#endif + var requestInfo = ToGetRequestInformation(requestConfiguration); + var errorMapping = new Dictionary> + { + { "404", global::GitHub.Models.BasicError.CreateFromDiscriminatorValue }, + }; + return await RequestAdapter.SendAsync(requestInfo, global::GitHub.Models.OrgPrivateRegistryConfiguration.CreateFromDiscriminatorValue, errorMapping, cancellationToken).ConfigureAwait(false); + } + /// + /// > [!NOTE]> This endpoint is in public preview and is subject to change.Updates a private registry configuration with an encrypted value for an organization. Encrypt your secret using [LibSodium](https://libsodium.gitbook.io/doc/bindings_for_other_languages). For more information, see "[Encrypting secrets for the REST API](https://docs.github.com/enterprise-cloud@latest//rest/guides/encrypting-secrets-for-the-rest-api)."OAuth app tokens and personal access tokens (classic) need the `admin:org` scope to use this endpoint. + /// API method documentation + /// + /// The request body + /// Cancellation token to use when cancelling requests + /// Configuration for the request such as headers, query parameters, and middleware options. + /// When receiving a 404 status code + /// When receiving a 422 status code +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public async Task PatchAsync(global::GitHub.Orgs.Item.PrivateRegistries.Item.WithSecret_namePatchRequestBody body, Action>? requestConfiguration = default, CancellationToken cancellationToken = default) + { +#nullable restore +#else + public async Task PatchAsync(global::GitHub.Orgs.Item.PrivateRegistries.Item.WithSecret_namePatchRequestBody body, Action> requestConfiguration = default, CancellationToken cancellationToken = default) + { +#endif + _ = body ?? throw new ArgumentNullException(nameof(body)); + var requestInfo = ToPatchRequestInformation(body, requestConfiguration); + var errorMapping = new Dictionary> + { + { "404", global::GitHub.Models.BasicError.CreateFromDiscriminatorValue }, + { "422", global::GitHub.Models.ValidationError.CreateFromDiscriminatorValue }, + }; + await RequestAdapter.SendNoContentAsync(requestInfo, errorMapping, cancellationToken).ConfigureAwait(false); + } + /// + /// > [!NOTE]> This endpoint is in public preview and is subject to change.Delete a private registry configuration at the organization-level.OAuth app tokens and personal access tokens (classic) need the `admin:org` scope to use this endpoint. + /// + /// A + /// Configuration for the request such as headers, query parameters, and middleware options. +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public RequestInformation ToDeleteRequestInformation(Action>? requestConfiguration = default) + { +#nullable restore +#else + public RequestInformation ToDeleteRequestInformation(Action> requestConfiguration = default) + { +#endif + var requestInfo = new RequestInformation(Method.DELETE, UrlTemplate, PathParameters); + requestInfo.Configure(requestConfiguration); + requestInfo.Headers.TryAdd("Accept", "application/json, application/scim+json"); + return requestInfo; + } + /// + /// > [!NOTE]> This endpoint is in public preview and is subject to change.Get the configuration of a single private registry defined for an organization, omitting its encrypted value.OAuth app tokens and personal access tokens (classic) need the `admin:org` scope to use this endpoint. + /// + /// A + /// Configuration for the request such as headers, query parameters, and middleware options. +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public RequestInformation ToGetRequestInformation(Action>? requestConfiguration = default) + { +#nullable restore +#else + public RequestInformation ToGetRequestInformation(Action> requestConfiguration = default) + { +#endif + var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters); + requestInfo.Configure(requestConfiguration); + requestInfo.Headers.TryAdd("Accept", "application/json"); + return requestInfo; + } + /// + /// > [!NOTE]> This endpoint is in public preview and is subject to change.Updates a private registry configuration with an encrypted value for an organization. Encrypt your secret using [LibSodium](https://libsodium.gitbook.io/doc/bindings_for_other_languages). For more information, see "[Encrypting secrets for the REST API](https://docs.github.com/enterprise-cloud@latest//rest/guides/encrypting-secrets-for-the-rest-api)."OAuth app tokens and personal access tokens (classic) need the `admin:org` scope to use this endpoint. + /// + /// A + /// The request body + /// Configuration for the request such as headers, query parameters, and middleware options. +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public RequestInformation ToPatchRequestInformation(global::GitHub.Orgs.Item.PrivateRegistries.Item.WithSecret_namePatchRequestBody body, Action>? requestConfiguration = default) + { +#nullable restore +#else + public RequestInformation ToPatchRequestInformation(global::GitHub.Orgs.Item.PrivateRegistries.Item.WithSecret_namePatchRequestBody body, Action> requestConfiguration = default) + { +#endif + _ = body ?? throw new ArgumentNullException(nameof(body)); + var requestInfo = new RequestInformation(Method.PATCH, UrlTemplate, PathParameters); + requestInfo.Configure(requestConfiguration); + requestInfo.Headers.TryAdd("Accept", "application/json"); + requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body); + return requestInfo; + } + /// + /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + /// + /// A + /// The raw URL to use for the request builder. + public global::GitHub.Orgs.Item.PrivateRegistries.Item.WithSecret_nameItemRequestBuilder WithUrl(string rawUrl) + { + return new global::GitHub.Orgs.Item.PrivateRegistries.Item.WithSecret_nameItemRequestBuilder(rawUrl, RequestAdapter); + } + } +} +#pragma warning restore CS0618 diff --git a/src/GitHub/Orgs/Item/PrivateRegistries/Item/WithSecret_namePatchRequestBody.cs b/src/GitHub/Orgs/Item/PrivateRegistries/Item/WithSecret_namePatchRequestBody.cs new file mode 100644 index 00000000..f50ea83b --- /dev/null +++ b/src/GitHub/Orgs/Item/PrivateRegistries/Item/WithSecret_namePatchRequestBody.cs @@ -0,0 +1,103 @@ +// +#pragma warning disable CS0618 +using Microsoft.Kiota.Abstractions.Extensions; +using Microsoft.Kiota.Abstractions.Serialization; +using System.Collections.Generic; +using System.IO; +using System; +namespace GitHub.Orgs.Item.PrivateRegistries.Item +{ + [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.19.0")] + #pragma warning disable CS1591 + public partial class WithSecret_namePatchRequestBody : IAdditionalDataHolder, IParsable + #pragma warning restore CS1591 + { + /// Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. + public IDictionary AdditionalData { get; set; } + /// The value for your secret, encrypted with [LibSodium](https://libsodium.gitbook.io/doc/bindings_for_other_languages) using the public key retrieved from the [Get private registries public key for an organization](https://docs.github.com/enterprise-cloud@latest//rest/private-registries/organization-configurations#get-private-registries-public-key-for-an-organization) endpoint. +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? EncryptedValue { get; set; } +#nullable restore +#else + public string EncryptedValue { get; set; } +#endif + /// The ID of the key you used to encrypt the secret. +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? KeyId { get; set; } +#nullable restore +#else + public string KeyId { get; set; } +#endif + /// The registry type. + public global::GitHub.Orgs.Item.PrivateRegistries.Item.WithSecret_namePatchRequestBody_registry_type? RegistryType { get; set; } + /// An array of repository IDs that can access the organization private registry. You can only provide a list of repository IDs when `visibility` is set to `selected`. This field should be omitted if `visibility` is set to `all` or `private`. +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public List? SelectedRepositoryIds { get; set; } +#nullable restore +#else + public List SelectedRepositoryIds { get; set; } +#endif + /// The username to use when authenticating with the private registry. This field should be omitted if the private registry does not require a username for authentication. +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Username { get; set; } +#nullable restore +#else + public string Username { get; set; } +#endif + /// Which type of organization repositories have access to the private registry. `selected` means only the repositories specified by `selected_repository_ids` can access the private registry. + public global::GitHub.Orgs.Item.PrivateRegistries.Item.WithSecret_namePatchRequestBody_visibility? Visibility { get; set; } + /// + /// Instantiates a new and sets the default values. + /// + public WithSecret_namePatchRequestBody() + { + AdditionalData = new Dictionary(); + } + /// + /// Creates a new instance of the appropriate class based on discriminator value + /// + /// A + /// The parse node to use to read the discriminator value and create the object + public static global::GitHub.Orgs.Item.PrivateRegistries.Item.WithSecret_namePatchRequestBody CreateFromDiscriminatorValue(IParseNode parseNode) + { + _ = parseNode ?? throw new ArgumentNullException(nameof(parseNode)); + return new global::GitHub.Orgs.Item.PrivateRegistries.Item.WithSecret_namePatchRequestBody(); + } + /// + /// The deserialization information for the current model + /// + /// A IDictionary<string, Action<IParseNode>> + public virtual IDictionary> GetFieldDeserializers() + { + return new Dictionary> + { + { "encrypted_value", n => { EncryptedValue = n.GetStringValue(); } }, + { "key_id", n => { KeyId = n.GetStringValue(); } }, + { "registry_type", n => { RegistryType = n.GetEnumValue(); } }, + { "selected_repository_ids", n => { SelectedRepositoryIds = n.GetCollectionOfPrimitiveValues()?.AsList(); } }, + { "username", n => { Username = n.GetStringValue(); } }, + { "visibility", n => { Visibility = n.GetEnumValue(); } }, + }; + } + /// + /// Serializes information the current object + /// + /// Serialization writer to use to serialize this model + public virtual void Serialize(ISerializationWriter writer) + { + _ = writer ?? throw new ArgumentNullException(nameof(writer)); + writer.WriteStringValue("encrypted_value", EncryptedValue); + writer.WriteStringValue("key_id", KeyId); + writer.WriteEnumValue("registry_type", RegistryType); + writer.WriteCollectionOfPrimitiveValues("selected_repository_ids", SelectedRepositoryIds); + writer.WriteStringValue("username", Username); + writer.WriteEnumValue("visibility", Visibility); + writer.WriteAdditionalData(AdditionalData); + } + } +} +#pragma warning restore CS0618 diff --git a/src/GitHub/Orgs/Item/PrivateRegistries/Item/WithSecret_namePatchRequestBody_registry_type.cs b/src/GitHub/Orgs/Item/PrivateRegistries/Item/WithSecret_namePatchRequestBody_registry_type.cs new file mode 100644 index 00000000..9d20522e --- /dev/null +++ b/src/GitHub/Orgs/Item/PrivateRegistries/Item/WithSecret_namePatchRequestBody_registry_type.cs @@ -0,0 +1,15 @@ +// +using System.Runtime.Serialization; +using System; +namespace GitHub.Orgs.Item.PrivateRegistries.Item +{ + /// The registry type. + [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.19.0")] + public enum WithSecret_namePatchRequestBody_registry_type + { + [EnumMember(Value = "maven_repository")] + #pragma warning disable CS1591 + Maven_repository, + #pragma warning restore CS1591 + } +} diff --git a/src/GitHub/Orgs/Item/PrivateRegistries/Item/WithSecret_namePatchRequestBody_visibility.cs b/src/GitHub/Orgs/Item/PrivateRegistries/Item/WithSecret_namePatchRequestBody_visibility.cs new file mode 100644 index 00000000..44cf412a --- /dev/null +++ b/src/GitHub/Orgs/Item/PrivateRegistries/Item/WithSecret_namePatchRequestBody_visibility.cs @@ -0,0 +1,23 @@ +// +using System.Runtime.Serialization; +using System; +namespace GitHub.Orgs.Item.PrivateRegistries.Item +{ + /// Which type of organization repositories have access to the private registry. `selected` means only the repositories specified by `selected_repository_ids` can access the private registry. + [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.19.0")] + public enum WithSecret_namePatchRequestBody_visibility + { + [EnumMember(Value = "all")] + #pragma warning disable CS1591 + All, + #pragma warning restore CS1591 + [EnumMember(Value = "private")] + #pragma warning disable CS1591 + Private, + #pragma warning restore CS1591 + [EnumMember(Value = "selected")] + #pragma warning disable CS1591 + Selected, + #pragma warning restore CS1591 + } +} diff --git a/src/GitHub/Orgs/Item/PrivateRegistries/PrivateRegistriesGetResponse.cs b/src/GitHub/Orgs/Item/PrivateRegistries/PrivateRegistriesGetResponse.cs new file mode 100644 index 00000000..49fb73b9 --- /dev/null +++ b/src/GitHub/Orgs/Item/PrivateRegistries/PrivateRegistriesGetResponse.cs @@ -0,0 +1,70 @@ +// +#pragma warning disable CS0618 +using GitHub.Models; +using Microsoft.Kiota.Abstractions.Extensions; +using Microsoft.Kiota.Abstractions.Serialization; +using System.Collections.Generic; +using System.IO; +using System; +namespace GitHub.Orgs.Item.PrivateRegistries +{ + [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.19.0")] + #pragma warning disable CS1591 + public partial class PrivateRegistriesGetResponse : IAdditionalDataHolder, IParsable + #pragma warning restore CS1591 + { + /// Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. + public IDictionary AdditionalData { get; set; } + /// The configurations property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public List? Configurations { get; set; } +#nullable restore +#else + public List Configurations { get; set; } +#endif + /// The total_count property + public int? TotalCount { get; set; } + /// + /// Instantiates a new and sets the default values. + /// + public PrivateRegistriesGetResponse() + { + AdditionalData = new Dictionary(); + } + /// + /// Creates a new instance of the appropriate class based on discriminator value + /// + /// A + /// The parse node to use to read the discriminator value and create the object + public static global::GitHub.Orgs.Item.PrivateRegistries.PrivateRegistriesGetResponse CreateFromDiscriminatorValue(IParseNode parseNode) + { + _ = parseNode ?? throw new ArgumentNullException(nameof(parseNode)); + return new global::GitHub.Orgs.Item.PrivateRegistries.PrivateRegistriesGetResponse(); + } + /// + /// The deserialization information for the current model + /// + /// A IDictionary<string, Action<IParseNode>> + public virtual IDictionary> GetFieldDeserializers() + { + return new Dictionary> + { + { "configurations", n => { Configurations = n.GetCollectionOfObjectValues(global::GitHub.Models.OrgPrivateRegistryConfiguration.CreateFromDiscriminatorValue)?.AsList(); } }, + { "total_count", n => { TotalCount = n.GetIntValue(); } }, + }; + } + /// + /// Serializes information the current object + /// + /// Serialization writer to use to serialize this model + public virtual void Serialize(ISerializationWriter writer) + { + _ = writer ?? throw new ArgumentNullException(nameof(writer)); + writer.WriteCollectionOfObjectValues("configurations", Configurations); + writer.WriteIntValue("total_count", TotalCount); + writer.WriteAdditionalData(AdditionalData); + } + } +} +#pragma warning restore CS0618 diff --git a/src/GitHub/Orgs/Item/PrivateRegistries/PrivateRegistriesPostRequestBody.cs b/src/GitHub/Orgs/Item/PrivateRegistries/PrivateRegistriesPostRequestBody.cs new file mode 100644 index 00000000..5cb0d724 --- /dev/null +++ b/src/GitHub/Orgs/Item/PrivateRegistries/PrivateRegistriesPostRequestBody.cs @@ -0,0 +1,103 @@ +// +#pragma warning disable CS0618 +using Microsoft.Kiota.Abstractions.Extensions; +using Microsoft.Kiota.Abstractions.Serialization; +using System.Collections.Generic; +using System.IO; +using System; +namespace GitHub.Orgs.Item.PrivateRegistries +{ + [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.19.0")] + #pragma warning disable CS1591 + public partial class PrivateRegistriesPostRequestBody : IAdditionalDataHolder, IParsable + #pragma warning restore CS1591 + { + /// Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. + public IDictionary AdditionalData { get; set; } + /// The value for your secret, encrypted with [LibSodium](https://libsodium.gitbook.io/doc/bindings_for_other_languages) using the public key retrieved from the [Get private registries public key for an organization](https://docs.github.com/enterprise-cloud@latest//rest/private-registries/organization-configurations#get-private-registries-public-key-for-an-organization) endpoint. +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? EncryptedValue { get; set; } +#nullable restore +#else + public string EncryptedValue { get; set; } +#endif + /// The ID of the key you used to encrypt the secret. +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? KeyId { get; set; } +#nullable restore +#else + public string KeyId { get; set; } +#endif + /// The registry type. + public global::GitHub.Orgs.Item.PrivateRegistries.PrivateRegistriesPostRequestBody_registry_type? RegistryType { get; set; } + /// An array of repository IDs that can access the organization private registry. You can only provide a list of repository IDs when `visibility` is set to `selected`. You can manage the list of selected repositories using the [Update a private registry for an organization](https://docs.github.com/enterprise-cloud@latest//rest/private-registries/organization-configurations#update-a-private-registry-for-an-organization) endpoint. This field should be omitted if `visibility` is set to `all` or `private`. +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public List? SelectedRepositoryIds { get; set; } +#nullable restore +#else + public List SelectedRepositoryIds { get; set; } +#endif + /// The username to use when authenticating with the private registry. This field should be omitted if the private registry does not require a username for authentication. +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Username { get; set; } +#nullable restore +#else + public string Username { get; set; } +#endif + /// Which type of organization repositories have access to the private registry. `selected` means only the repositories specified by `selected_repository_ids` can access the private registry. + public global::GitHub.Orgs.Item.PrivateRegistries.PrivateRegistriesPostRequestBody_visibility? Visibility { get; set; } + /// + /// Instantiates a new and sets the default values. + /// + public PrivateRegistriesPostRequestBody() + { + AdditionalData = new Dictionary(); + } + /// + /// Creates a new instance of the appropriate class based on discriminator value + /// + /// A + /// The parse node to use to read the discriminator value and create the object + public static global::GitHub.Orgs.Item.PrivateRegistries.PrivateRegistriesPostRequestBody CreateFromDiscriminatorValue(IParseNode parseNode) + { + _ = parseNode ?? throw new ArgumentNullException(nameof(parseNode)); + return new global::GitHub.Orgs.Item.PrivateRegistries.PrivateRegistriesPostRequestBody(); + } + /// + /// The deserialization information for the current model + /// + /// A IDictionary<string, Action<IParseNode>> + public virtual IDictionary> GetFieldDeserializers() + { + return new Dictionary> + { + { "encrypted_value", n => { EncryptedValue = n.GetStringValue(); } }, + { "key_id", n => { KeyId = n.GetStringValue(); } }, + { "registry_type", n => { RegistryType = n.GetEnumValue(); } }, + { "selected_repository_ids", n => { SelectedRepositoryIds = n.GetCollectionOfPrimitiveValues()?.AsList(); } }, + { "username", n => { Username = n.GetStringValue(); } }, + { "visibility", n => { Visibility = n.GetEnumValue(); } }, + }; + } + /// + /// Serializes information the current object + /// + /// Serialization writer to use to serialize this model + public virtual void Serialize(ISerializationWriter writer) + { + _ = writer ?? throw new ArgumentNullException(nameof(writer)); + writer.WriteStringValue("encrypted_value", EncryptedValue); + writer.WriteStringValue("key_id", KeyId); + writer.WriteEnumValue("registry_type", RegistryType); + writer.WriteCollectionOfPrimitiveValues("selected_repository_ids", SelectedRepositoryIds); + writer.WriteStringValue("username", Username); + writer.WriteEnumValue("visibility", Visibility); + writer.WriteAdditionalData(AdditionalData); + } + } +} +#pragma warning restore CS0618 diff --git a/src/GitHub/Orgs/Item/PrivateRegistries/PrivateRegistriesPostRequestBody_registry_type.cs b/src/GitHub/Orgs/Item/PrivateRegistries/PrivateRegistriesPostRequestBody_registry_type.cs new file mode 100644 index 00000000..7cc66777 --- /dev/null +++ b/src/GitHub/Orgs/Item/PrivateRegistries/PrivateRegistriesPostRequestBody_registry_type.cs @@ -0,0 +1,15 @@ +// +using System.Runtime.Serialization; +using System; +namespace GitHub.Orgs.Item.PrivateRegistries +{ + /// The registry type. + [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.19.0")] + public enum PrivateRegistriesPostRequestBody_registry_type + { + [EnumMember(Value = "maven_repository")] + #pragma warning disable CS1591 + Maven_repository, + #pragma warning restore CS1591 + } +} diff --git a/src/GitHub/Orgs/Item/PrivateRegistries/PrivateRegistriesPostRequestBody_visibility.cs b/src/GitHub/Orgs/Item/PrivateRegistries/PrivateRegistriesPostRequestBody_visibility.cs new file mode 100644 index 00000000..6dbdb78e --- /dev/null +++ b/src/GitHub/Orgs/Item/PrivateRegistries/PrivateRegistriesPostRequestBody_visibility.cs @@ -0,0 +1,23 @@ +// +using System.Runtime.Serialization; +using System; +namespace GitHub.Orgs.Item.PrivateRegistries +{ + /// Which type of organization repositories have access to the private registry. `selected` means only the repositories specified by `selected_repository_ids` can access the private registry. + [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.19.0")] + public enum PrivateRegistriesPostRequestBody_visibility + { + [EnumMember(Value = "all")] + #pragma warning disable CS1591 + All, + #pragma warning restore CS1591 + [EnumMember(Value = "private")] + #pragma warning disable CS1591 + Private, + #pragma warning restore CS1591 + [EnumMember(Value = "selected")] + #pragma warning disable CS1591 + Selected, + #pragma warning restore CS1591 + } +} diff --git a/src/GitHub/Orgs/Item/PrivateRegistries/PrivateRegistriesRequestBuilder.cs b/src/GitHub/Orgs/Item/PrivateRegistries/PrivateRegistriesRequestBuilder.cs new file mode 100644 index 00000000..a2dd26e0 --- /dev/null +++ b/src/GitHub/Orgs/Item/PrivateRegistries/PrivateRegistriesRequestBuilder.cs @@ -0,0 +1,174 @@ +// +#pragma warning disable CS0618 +using GitHub.Models; +using GitHub.Orgs.Item.PrivateRegistries.Item; +using GitHub.Orgs.Item.PrivateRegistries.PublicKey; +using Microsoft.Kiota.Abstractions.Extensions; +using Microsoft.Kiota.Abstractions.Serialization; +using Microsoft.Kiota.Abstractions; +using System.Collections.Generic; +using System.IO; +using System.Threading.Tasks; +using System.Threading; +using System; +namespace GitHub.Orgs.Item.PrivateRegistries +{ + /// + /// Builds and executes requests for operations under \orgs\{org}\private-registries + /// + [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.19.0")] + public partial class PrivateRegistriesRequestBuilder : BaseRequestBuilder + { + /// The publicKey property + public global::GitHub.Orgs.Item.PrivateRegistries.PublicKey.PublicKeyRequestBuilder PublicKey + { + get => new global::GitHub.Orgs.Item.PrivateRegistries.PublicKey.PublicKeyRequestBuilder(PathParameters, RequestAdapter); + } + /// Gets an item from the GitHub.orgs.item.privateRegistries.item collection + /// The name of the secret. + /// A + public global::GitHub.Orgs.Item.PrivateRegistries.Item.WithSecret_nameItemRequestBuilder this[string position] + { + get + { + var urlTplParams = new Dictionary(PathParameters); + urlTplParams.Add("secret_name", position); + return new global::GitHub.Orgs.Item.PrivateRegistries.Item.WithSecret_nameItemRequestBuilder(urlTplParams, RequestAdapter); + } + } + /// + /// Instantiates a new and sets the default values. + /// + /// Path parameters for the request + /// The request adapter to use to execute the requests. + public PrivateRegistriesRequestBuilder(Dictionary pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/orgs/{org}/private-registries{?page*,per_page*}", pathParameters) + { + } + /// + /// Instantiates a new and sets the default values. + /// + /// The raw URL to use for the request builder. + /// The request adapter to use to execute the requests. + public PrivateRegistriesRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/orgs/{org}/private-registries{?page*,per_page*}", rawUrl) + { + } + /// + /// > [!NOTE]> This endpoint is in public preview and is subject to change.Lists all private registry configurations available at the organization-level without revealing their encryptedvalues.OAuth app tokens and personal access tokens (classic) need the `admin:org` scope to use this endpoint. + /// API method documentation + /// + /// A + /// Cancellation token to use when cancelling requests + /// Configuration for the request such as headers, query parameters, and middleware options. + /// When receiving a 400 status code + /// When receiving a 404 status code +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public async Task GetAsync(Action>? requestConfiguration = default, CancellationToken cancellationToken = default) + { +#nullable restore +#else + public async Task GetAsync(Action> requestConfiguration = default, CancellationToken cancellationToken = default) + { +#endif + var requestInfo = ToGetRequestInformation(requestConfiguration); + var errorMapping = new Dictionary> + { + { "400", global::GitHub.Models.BasicError.CreateFromDiscriminatorValue }, + { "404", global::GitHub.Models.BasicError.CreateFromDiscriminatorValue }, + }; + return await RequestAdapter.SendAsync(requestInfo, global::GitHub.Orgs.Item.PrivateRegistries.PrivateRegistriesGetResponse.CreateFromDiscriminatorValue, errorMapping, cancellationToken).ConfigureAwait(false); + } + /// + /// > [!NOTE]> This endpoint is in public preview and is subject to change.Creates a private registry configuration with an encrypted value for an organization. Encrypt your secret using [LibSodium](https://libsodium.gitbook.io/doc/bindings_for_other_languages). For more information, see "[Encrypting secrets for the REST API](https://docs.github.com/enterprise-cloud@latest//rest/guides/encrypting-secrets-for-the-rest-api)."OAuth app tokens and personal access tokens (classic) need the `admin:org` scope to use this endpoint. + /// API method documentation + /// + /// A + /// The request body + /// Cancellation token to use when cancelling requests + /// Configuration for the request such as headers, query parameters, and middleware options. + /// When receiving a 404 status code + /// When receiving a 422 status code +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public async Task PostAsync(global::GitHub.Orgs.Item.PrivateRegistries.PrivateRegistriesPostRequestBody body, Action>? requestConfiguration = default, CancellationToken cancellationToken = default) + { +#nullable restore +#else + public async Task PostAsync(global::GitHub.Orgs.Item.PrivateRegistries.PrivateRegistriesPostRequestBody body, Action> requestConfiguration = default, CancellationToken cancellationToken = default) + { +#endif + _ = body ?? throw new ArgumentNullException(nameof(body)); + var requestInfo = ToPostRequestInformation(body, requestConfiguration); + var errorMapping = new Dictionary> + { + { "404", global::GitHub.Models.BasicError.CreateFromDiscriminatorValue }, + { "422", global::GitHub.Models.ValidationError.CreateFromDiscriminatorValue }, + }; + return await RequestAdapter.SendAsync(requestInfo, global::GitHub.Models.OrgPrivateRegistryConfigurationWithSelectedRepositories.CreateFromDiscriminatorValue, errorMapping, cancellationToken).ConfigureAwait(false); + } + /// + /// > [!NOTE]> This endpoint is in public preview and is subject to change.Lists all private registry configurations available at the organization-level without revealing their encryptedvalues.OAuth app tokens and personal access tokens (classic) need the `admin:org` scope to use this endpoint. + /// + /// A + /// Configuration for the request such as headers, query parameters, and middleware options. +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public RequestInformation ToGetRequestInformation(Action>? requestConfiguration = default) + { +#nullable restore +#else + public RequestInformation ToGetRequestInformation(Action> requestConfiguration = default) + { +#endif + var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters); + requestInfo.Configure(requestConfiguration); + requestInfo.Headers.TryAdd("Accept", "application/json"); + return requestInfo; + } + /// + /// > [!NOTE]> This endpoint is in public preview and is subject to change.Creates a private registry configuration with an encrypted value for an organization. Encrypt your secret using [LibSodium](https://libsodium.gitbook.io/doc/bindings_for_other_languages). For more information, see "[Encrypting secrets for the REST API](https://docs.github.com/enterprise-cloud@latest//rest/guides/encrypting-secrets-for-the-rest-api)."OAuth app tokens and personal access tokens (classic) need the `admin:org` scope to use this endpoint. + /// + /// A + /// The request body + /// Configuration for the request such as headers, query parameters, and middleware options. +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public RequestInformation ToPostRequestInformation(global::GitHub.Orgs.Item.PrivateRegistries.PrivateRegistriesPostRequestBody body, Action>? requestConfiguration = default) + { +#nullable restore +#else + public RequestInformation ToPostRequestInformation(global::GitHub.Orgs.Item.PrivateRegistries.PrivateRegistriesPostRequestBody body, Action> requestConfiguration = default) + { +#endif + _ = body ?? throw new ArgumentNullException(nameof(body)); + var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters); + requestInfo.Configure(requestConfiguration); + requestInfo.Headers.TryAdd("Accept", "application/json"); + requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body); + return requestInfo; + } + /// + /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + /// + /// A + /// The raw URL to use for the request builder. + public global::GitHub.Orgs.Item.PrivateRegistries.PrivateRegistriesRequestBuilder WithUrl(string rawUrl) + { + return new global::GitHub.Orgs.Item.PrivateRegistries.PrivateRegistriesRequestBuilder(rawUrl, RequestAdapter); + } + /// + /// > [!NOTE]> This endpoint is in public preview and is subject to change.Lists all private registry configurations available at the organization-level without revealing their encryptedvalues.OAuth app tokens and personal access tokens (classic) need the `admin:org` scope to use this endpoint. + /// + [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.19.0")] + public partial class PrivateRegistriesRequestBuilderGetQueryParameters + { + /// The page number of the results to fetch. For more information, see "[Using pagination in the REST API](https://docs.github.com/enterprise-cloud@latest//rest/using-the-rest-api/using-pagination-in-the-rest-api)." + [QueryParameter("page")] + public int? Page { get; set; } + /// The number of results per page (max 100). For more information, see "[Using pagination in the REST API](https://docs.github.com/enterprise-cloud@latest//rest/using-the-rest-api/using-pagination-in-the-rest-api)." + [QueryParameter("per_page")] + public int? PerPage { get; set; } + } + } +} +#pragma warning restore CS0618 diff --git a/src/GitHub/Models/Users_matches.cs b/src/GitHub/Orgs/Item/PrivateRegistries/PublicKey/PublicKeyGetResponse.cs similarity index 63% rename from src/GitHub/Models/Users_matches.cs rename to src/GitHub/Orgs/Item/PrivateRegistries/PublicKey/PublicKeyGetResponse.cs index 02c4f2f4..075a5ae1 100644 --- a/src/GitHub/Models/Users_matches.cs +++ b/src/GitHub/Orgs/Item/PrivateRegistries/PublicKey/PublicKeyGetResponse.cs @@ -5,47 +5,47 @@ using System.Collections.Generic; using System.IO; using System; -namespace GitHub.Models +namespace GitHub.Orgs.Item.PrivateRegistries.PublicKey { [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.19.0")] #pragma warning disable CS1591 - public partial class Users_matches : IAdditionalDataHolder, IParsable + public partial class PublicKeyGetResponse : IAdditionalDataHolder, IParsable #pragma warning restore CS1591 { /// Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. public IDictionary AdditionalData { get; set; } - /// The indices property + /// The Base64 encoded public key. #if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER #nullable enable - public List? Indices { get; set; } + public string? Key { get; set; } #nullable restore #else - public List Indices { get; set; } + public string Key { get; set; } #endif - /// The text property + /// The identifier for the key. #if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER #nullable enable - public string? Text { get; set; } + public string? KeyId { get; set; } #nullable restore #else - public string Text { get; set; } + public string KeyId { get; set; } #endif /// - /// Instantiates a new and sets the default values. + /// Instantiates a new and sets the default values. /// - public Users_matches() + public PublicKeyGetResponse() { AdditionalData = new Dictionary(); } /// /// Creates a new instance of the appropriate class based on discriminator value /// - /// A + /// A /// The parse node to use to read the discriminator value and create the object - public static global::GitHub.Models.Users_matches CreateFromDiscriminatorValue(IParseNode parseNode) + public static global::GitHub.Orgs.Item.PrivateRegistries.PublicKey.PublicKeyGetResponse CreateFromDiscriminatorValue(IParseNode parseNode) { _ = parseNode ?? throw new ArgumentNullException(nameof(parseNode)); - return new global::GitHub.Models.Users_matches(); + return new global::GitHub.Orgs.Item.PrivateRegistries.PublicKey.PublicKeyGetResponse(); } /// /// The deserialization information for the current model @@ -55,8 +55,8 @@ public virtual IDictionary> GetFieldDeserializers() { return new Dictionary> { - { "indices", n => { Indices = n.GetCollectionOfPrimitiveValues()?.AsList(); } }, - { "text", n => { Text = n.GetStringValue(); } }, + { "key", n => { Key = n.GetStringValue(); } }, + { "key_id", n => { KeyId = n.GetStringValue(); } }, }; } /// @@ -66,8 +66,8 @@ public virtual IDictionary> GetFieldDeserializers() public virtual void Serialize(ISerializationWriter writer) { _ = writer ?? throw new ArgumentNullException(nameof(writer)); - writer.WriteCollectionOfPrimitiveValues("indices", Indices); - writer.WriteStringValue("text", Text); + writer.WriteStringValue("key", Key); + writer.WriteStringValue("key_id", KeyId); writer.WriteAdditionalData(AdditionalData); } } diff --git a/src/GitHub/Orgs/Item/PrivateRegistries/PublicKey/PublicKeyRequestBuilder.cs b/src/GitHub/Orgs/Item/PrivateRegistries/PublicKey/PublicKeyRequestBuilder.cs new file mode 100644 index 00000000..4261238c --- /dev/null +++ b/src/GitHub/Orgs/Item/PrivateRegistries/PublicKey/PublicKeyRequestBuilder.cs @@ -0,0 +1,90 @@ +// +#pragma warning disable CS0618 +using GitHub.Models; +using Microsoft.Kiota.Abstractions.Extensions; +using Microsoft.Kiota.Abstractions.Serialization; +using Microsoft.Kiota.Abstractions; +using System.Collections.Generic; +using System.IO; +using System.Threading.Tasks; +using System.Threading; +using System; +namespace GitHub.Orgs.Item.PrivateRegistries.PublicKey +{ + /// + /// Builds and executes requests for operations under \orgs\{org}\private-registries\public-key + /// + [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.19.0")] + public partial class PublicKeyRequestBuilder : BaseRequestBuilder + { + /// + /// Instantiates a new and sets the default values. + /// + /// Path parameters for the request + /// The request adapter to use to execute the requests. + public PublicKeyRequestBuilder(Dictionary pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/orgs/{org}/private-registries/public-key", pathParameters) + { + } + /// + /// Instantiates a new and sets the default values. + /// + /// The raw URL to use for the request builder. + /// The request adapter to use to execute the requests. + public PublicKeyRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/orgs/{org}/private-registries/public-key", rawUrl) + { + } + /// + /// > [!NOTE]> This endpoint is in public preview and is subject to change.Gets the org public key, which is needed to encrypt private registry secrets. You need to encrypt a secret before you can create or update secrets.OAuth tokens and personal access tokens (classic) need the `admin:org` scope to use this endpoint. + /// API method documentation + /// + /// A + /// Cancellation token to use when cancelling requests + /// Configuration for the request such as headers, query parameters, and middleware options. + /// When receiving a 404 status code +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public async Task GetAsync(Action>? requestConfiguration = default, CancellationToken cancellationToken = default) + { +#nullable restore +#else + public async Task GetAsync(Action> requestConfiguration = default, CancellationToken cancellationToken = default) + { +#endif + var requestInfo = ToGetRequestInformation(requestConfiguration); + var errorMapping = new Dictionary> + { + { "404", global::GitHub.Models.BasicError.CreateFromDiscriminatorValue }, + }; + return await RequestAdapter.SendAsync(requestInfo, global::GitHub.Orgs.Item.PrivateRegistries.PublicKey.PublicKeyGetResponse.CreateFromDiscriminatorValue, errorMapping, cancellationToken).ConfigureAwait(false); + } + /// + /// > [!NOTE]> This endpoint is in public preview and is subject to change.Gets the org public key, which is needed to encrypt private registry secrets. You need to encrypt a secret before you can create or update secrets.OAuth tokens and personal access tokens (classic) need the `admin:org` scope to use this endpoint. + /// + /// A + /// Configuration for the request such as headers, query parameters, and middleware options. +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public RequestInformation ToGetRequestInformation(Action>? requestConfiguration = default) + { +#nullable restore +#else + public RequestInformation ToGetRequestInformation(Action> requestConfiguration = default) + { +#endif + var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters); + requestInfo.Configure(requestConfiguration); + requestInfo.Headers.TryAdd("Accept", "application/json"); + return requestInfo; + } + /// + /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + /// + /// A + /// The raw URL to use for the request builder. + public global::GitHub.Orgs.Item.PrivateRegistries.PublicKey.PublicKeyRequestBuilder WithUrl(string rawUrl) + { + return new global::GitHub.Orgs.Item.PrivateRegistries.PublicKey.PublicKeyRequestBuilder(rawUrl, RequestAdapter); + } + } +} +#pragma warning restore CS0618 diff --git a/src/GitHub/Orgs/Item/WithOrgItemRequestBuilder.cs b/src/GitHub/Orgs/Item/WithOrgItemRequestBuilder.cs index 65008eb4..74f67832 100644 --- a/src/GitHub/Orgs/Item/WithOrgItemRequestBuilder.cs +++ b/src/GitHub/Orgs/Item/WithOrgItemRequestBuilder.cs @@ -38,6 +38,7 @@ using GitHub.Orgs.Item.Packages; using GitHub.Orgs.Item.PersonalAccessTokenRequests; using GitHub.Orgs.Item.PersonalAccessTokens; +using GitHub.Orgs.Item.PrivateRegistries; using GitHub.Orgs.Item.Projects; using GitHub.Orgs.Item.Properties; using GitHub.Orgs.Item.Public_members; @@ -247,6 +248,11 @@ public partial class WithOrgItemRequestBuilder : BaseRequestBuilder { get => new global::GitHub.Orgs.Item.PersonalAccessTokens.PersonalAccessTokensRequestBuilder(PathParameters, RequestAdapter); } + /// The privateRegistries property + public global::GitHub.Orgs.Item.PrivateRegistries.PrivateRegistriesRequestBuilder PrivateRegistries + { + get => new global::GitHub.Orgs.Item.PrivateRegistries.PrivateRegistriesRequestBuilder(PathParameters, RequestAdapter); + } /// The projects property public global::GitHub.Orgs.Item.Projects.ProjectsRequestBuilder Projects { diff --git a/src/GitHub/kiota-lock.json b/src/GitHub/kiota-lock.json index 278d76e7..57f218c5 100644 --- a/src/GitHub/kiota-lock.json +++ b/src/GitHub/kiota-lock.json @@ -1,5 +1,5 @@ { - "descriptionHash": "F94BFB679AB485E50D630C793DF9DD71FCDED74ABEE8669F15904A391A069694B7A82A114CE9EEE6C825CC35F342C3175223C4D4D37837F8E4DAC3CCF6FC8005", + "descriptionHash": "227AA9495DA3105FF81582DD86965B767B1026AC103961C834D82B7C09FC012448B70C448DF745E5AAC9F194124DDC5D2B5AEA49E0734E7CF8DA37FFB4E5A523", "descriptionLocation": "../../../../../schemas/ghec.json", "lockFileVersion": "1.0.0", "kiotaVersion": "1.19.0",