FeatureFlagsApi.md

LaunchDarkly.Api.Api.FeatureFlagsApi

All URIs are relative to https://app.launchdarkly.com/api/v2

Method	HTTP request	Description
CopyFeatureFlag	POST /flags/{projectKey}/{featureFlagKey}/copy	Copies the feature flag configuration from one environment to the same feature flag in another environment.
DeleteApprovalRequest	DELETE /projects/{projectKey}/flags/{featureFlagKey}/environments/{environmentKey}/approval-requests/{approvalRequestId}	Delete an approval request for a feature flag config
DeleteFeatureFlag	DELETE /flags/{projectKey}/{featureFlagKey}	Delete a feature flag in all environments. Be careful- - only delete feature flags that are no longer being used by your application.
DeleteFlagConfigScheduledChanges	DELETE /projects/{projectKey}/flags/{featureFlagKey}/environments/{environmentKey}/scheduled-changes/{scheduledChangeId}	Delete a scheduled change on a feature flag in an environment.
FlagsProjectKeyEnvironmentKeyFeatureFlagKeyDependentFlagsGet	GET /flags/{projectKey}/{environmentKey}/{featureFlagKey}/dependent-flags	Get dependent flags for the flag in the environment specified in path parameters
FlagsProjectKeyFeatureFlagKeyDependentFlagsGet	GET /flags/{projectKey}/{featureFlagKey}/dependent-flags	Get dependent flags across all environments for the flag specified in the path parameters
GetApprovalRequest	GET /projects/{projectKey}/flags/{featureFlagKey}/environments/{environmentKey}/approval-requests/{approvalRequestId}	Get a single approval request for a feature flag config
GetApprovalRequests	GET /projects/{projectKey}/flags/{featureFlagKey}/environments/{environmentKey}/approval-requests	Get all approval requests for a feature flag config
GetExpiringUserTargets	GET /flags/{projectKey}/{featureFlagKey}/expiring-user-targets/{environmentKey}	Get expiring user targets for feature flag
GetFeatureFlag	GET /flags/{projectKey}/{featureFlagKey}	Get a single feature flag by key.
GetFeatureFlagStatus	GET /flag-statuses/{projectKey}/{environmentKey}/{featureFlagKey}	Get the status for a particular feature flag.
GetFeatureFlagStatusAcrossEnvironments	GET /flag-status/{projectKey}/{featureFlagKey}	Get the status for a particular feature flag across environments
GetFeatureFlagStatuses	GET /flag-statuses/{projectKey}/{environmentKey}	Get a list of statuses for all feature flags. The status includes the last time the feature flag was requested, as well as the state of the flag.
GetFeatureFlags	GET /flags/{projectKey}	Get a list of all features in the given project.
GetFlagConfigScheduledChange	GET /projects/{projectKey}/flags/{featureFlagKey}/environments/{environmentKey}/scheduled-changes/{scheduledChangeId}	Get a scheduled change on a feature flag by id.
GetFlagConfigScheduledChanges	GET /projects/{projectKey}/flags/{featureFlagKey}/environments/{environmentKey}/scheduled-changes	Get all scheduled workflows for a feature flag by key.
GetFlagConfigScheduledChangesConflicts	POST /projects/{projectKey}/flags/{featureFlagKey}/environments/{environmentKey}/scheduled-changes-conflicts	Lists conflicts between the given instructions and any existing scheduled changes for the feature flag. The actual HTTP verb should be REPORT, not POST.
PatchExpiringUserTargets	PATCH /flags/{projectKey}/{featureFlagKey}/expiring-user-targets/{environmentKey}	Update, add, or delete expiring user targets on feature flag
PatchFeatureFlag	PATCH /flags/{projectKey}/{featureFlagKey}	Perform a partial update to a feature.
PatchFlagConfigScheduledChange	PATCH /projects/{projectKey}/flags/{featureFlagKey}/environments/{environmentKey}/scheduled-changes/{scheduledChangeId}	Updates an existing scheduled-change on a feature flag in an environment.
PostApplyApprovalRequest	POST /projects/{projectKey}/flags/{featureFlagKey}/environments/{environmentKey}/approval-requests/{approvalRequestId}/apply	Apply approval request for a feature flag config
PostApprovalRequest	POST /projects/{projectKey}/flags/{featureFlagKey}/environments/{environmentKey}/approval-requests/{approvalRequestId}	Create an approval request for a feature flag config
PostFeatureFlag	POST /flags/{projectKey}	Creates a new feature flag.
PostFlagConfigScheduledChanges	POST /projects/{projectKey}/flags/{featureFlagKey}/environments/{environmentKey}/scheduled-changes	Creates a new scheduled change for a feature flag.
PostReviewApprovalRequest	POST /projects/{projectKey}/flags/{featureFlagKey}/environments/{environmentKey}/approval-requests/{approvalRequestId}/review	Review approval request for a feature flag config

CopyFeatureFlag

FeatureFlag CopyFeatureFlag (string projectKey, string featureFlagKey, FeatureFlagCopyBody featureFlagCopyBody)

Copies the feature flag configuration from one environment to the same feature flag in another environment.

Example

using System;
using System.Diagnostics;
using LaunchDarkly.Api.Api;
using LaunchDarkly.Api.Client;
using LaunchDarkly.Api.Model;

namespace Example
{
    public class CopyFeatureFlagExample
    {
        public void main()
        {
            
            // Configure API key authorization: Token
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new FeatureFlagsApi();
            var projectKey = projectKey_example;  // string | The project key, used to tie the flags together under one project so they can be managed together.
            var featureFlagKey = featureFlagKey_example;  // string | The feature flag's key. The key identifies the flag in your code.
            var featureFlagCopyBody = new FeatureFlagCopyBody(); // FeatureFlagCopyBody | Copy feature flag configurations between environments.

            try
            {
                // Copies the feature flag configuration from one environment to the same feature flag in another environment.
                FeatureFlag result = apiInstance.CopyFeatureFlag(projectKey, featureFlagKey, featureFlagCopyBody);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FeatureFlagsApi.CopyFeatureFlag: " + e.Message );
            }
        }
    }
}

Parameters

Name	Type	Description	Notes
projectKey	string	The project key, used to tie the flags together under one project so they can be managed together.
featureFlagKey	string	The feature flag's key. The key identifies the flag in your code.
featureFlagCopyBody	FeatureFlagCopyBody	Copy feature flag configurations between environments.

Return type

FeatureFlag

Authorization

Token

HTTP request headers

• Content-Type: application/json
• Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

DeleteApprovalRequest

void DeleteApprovalRequest (string projectKey, string environmentKey, string featureFlagKey, string approvalRequestId, ApprovalRequestConfigBody approvalRequestConfigBody)

Delete an approval request for a feature flag config

Example

using System;
using System.Diagnostics;
using LaunchDarkly.Api.Api;
using LaunchDarkly.Api.Client;
using LaunchDarkly.Api.Model;

namespace Example
{
    public class DeleteApprovalRequestExample
    {
        public void main()
        {
            
            // Configure API key authorization: Token
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new FeatureFlagsApi();
            var projectKey = projectKey_example;  // string | The project key, used to tie the flags together under one project so they can be managed together.
            var environmentKey = environmentKey_example;  // string | The environment key, used to tie together flag configuration and users under one environment so they can be managed together.
            var featureFlagKey = featureFlagKey_example;  // string | The feature flag's key. The key identifies the flag in your code.
            var approvalRequestId = approvalRequestId_example;  // string | The approval request ID
            var approvalRequestConfigBody = new ApprovalRequestConfigBody(); // ApprovalRequestConfigBody | Create a new approval request (optional) 

            try
            {
                // Delete an approval request for a feature flag config
                apiInstance.DeleteApprovalRequest(projectKey, environmentKey, featureFlagKey, approvalRequestId, approvalRequestConfigBody);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FeatureFlagsApi.DeleteApprovalRequest: " + e.Message );
            }
        }
    }
}

Parameters

Name	Type	Description	Notes
projectKey	string	The project key, used to tie the flags together under one project so they can be managed together.
environmentKey	string	The environment key, used to tie together flag configuration and users under one environment so they can be managed together.
featureFlagKey	string	The feature flag's key. The key identifies the flag in your code.
approvalRequestId	string	The approval request ID
approvalRequestConfigBody	ApprovalRequestConfigBody	Create a new approval request	[optional]

Return type

void (empty response body)

Authorization

Token

HTTP request headers

• Content-Type: application/json
• Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

DeleteFeatureFlag

void DeleteFeatureFlag (string projectKey, string featureFlagKey)

Delete a feature flag in all environments. Be careful- - only delete feature flags that are no longer being used by your application.

Example

using System;
using System.Diagnostics;
using LaunchDarkly.Api.Api;
using LaunchDarkly.Api.Client;
using LaunchDarkly.Api.Model;

namespace Example
{
    public class DeleteFeatureFlagExample
    {
        public void main()
        {
            
            // Configure API key authorization: Token
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new FeatureFlagsApi();
            var projectKey = projectKey_example;  // string | The project key, used to tie the flags together under one project so they can be managed together.
            var featureFlagKey = featureFlagKey_example;  // string | The feature flag's key. The key identifies the flag in your code.

            try
            {
                // Delete a feature flag in all environments. Be careful- - only delete feature flags that are no longer being used by your application.
                apiInstance.DeleteFeatureFlag(projectKey, featureFlagKey);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FeatureFlagsApi.DeleteFeatureFlag: " + e.Message );
            }
        }
    }
}

Parameters

Name	Type	Description	Notes
projectKey	string	The project key, used to tie the flags together under one project so they can be managed together.
featureFlagKey	string	The feature flag's key. The key identifies the flag in your code.

Return type

void (empty response body)

Authorization

Token

HTTP request headers

• Content-Type: application/json
• Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

DeleteFlagConfigScheduledChanges

void DeleteFlagConfigScheduledChanges (string projectKey, string featureFlagKey, string environmentKey, string scheduledChangeId)

Delete a scheduled change on a feature flag in an environment.

Example

using System;
using System.Diagnostics;
using LaunchDarkly.Api.Api;
using LaunchDarkly.Api.Client;
using LaunchDarkly.Api.Model;

namespace Example
{
    public class DeleteFlagConfigScheduledChangesExample
    {
        public void main()
        {
            
            // Configure API key authorization: Token
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new FeatureFlagsApi();
            var projectKey = projectKey_example;  // string | The project key, used to tie the flags together under one project so they can be managed together.
            var featureFlagKey = featureFlagKey_example;  // string | The feature flag's key. The key identifies the flag in your code.
            var environmentKey = environmentKey_example;  // string | The environment key, used to tie together flag configuration and users under one environment so they can be managed together.
            var scheduledChangeId = scheduledChangeId_example;  // string | The id of the scheduled change

            try
            {
                // Delete a scheduled change on a feature flag in an environment.
                apiInstance.DeleteFlagConfigScheduledChanges(projectKey, featureFlagKey, environmentKey, scheduledChangeId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FeatureFlagsApi.DeleteFlagConfigScheduledChanges: " + e.Message );
            }
        }
    }
}

Parameters

Name	Type	Description	Notes
projectKey	string	The project key, used to tie the flags together under one project so they can be managed together.
featureFlagKey	string	The feature flag's key. The key identifies the flag in your code.
environmentKey	string	The environment key, used to tie together flag configuration and users under one environment so they can be managed together.
scheduledChangeId	string	The id of the scheduled change

Return type

void (empty response body)

Authorization

Token

HTTP request headers

• Content-Type: application/json
• Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

FlagsProjectKeyEnvironmentKeyFeatureFlagKeyDependentFlagsGet

DependentFlagsByEnvironment FlagsProjectKeyEnvironmentKeyFeatureFlagKeyDependentFlagsGet (string projectKey, string environmentKey, string featureFlagKey)

Get dependent flags for the flag in the environment specified in path parameters

Example

using System;
using System.Diagnostics;
using LaunchDarkly.Api.Api;
using LaunchDarkly.Api.Client;
using LaunchDarkly.Api.Model;

namespace Example
{
    public class FlagsProjectKeyEnvironmentKeyFeatureFlagKeyDependentFlagsGetExample
    {
        public void main()
        {
            
            // Configure API key authorization: Token
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new FeatureFlagsApi();
            var projectKey = projectKey_example;  // string | The project key, used to tie the flags together under one project so they can be managed together.
            var environmentKey = environmentKey_example;  // string | The environment key, used to tie together flag configuration and users under one environment so they can be managed together.
            var featureFlagKey = featureFlagKey_example;  // string | The feature flag's key. The key identifies the flag in your code.

            try
            {
                // Get dependent flags for the flag in the environment specified in path parameters
                DependentFlagsByEnvironment result = apiInstance.FlagsProjectKeyEnvironmentKeyFeatureFlagKeyDependentFlagsGet(projectKey, environmentKey, featureFlagKey);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FeatureFlagsApi.FlagsProjectKeyEnvironmentKeyFeatureFlagKeyDependentFlagsGet: " + e.Message );
            }
        }
    }
}

Parameters

Name	Type	Description	Notes
projectKey	string	The project key, used to tie the flags together under one project so they can be managed together.
environmentKey	string	The environment key, used to tie together flag configuration and users under one environment so they can be managed together.
featureFlagKey	string	The feature flag's key. The key identifies the flag in your code.

Return type

DependentFlagsByEnvironment

Authorization

Token

HTTP request headers

• Content-Type: application/json
• Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

FlagsProjectKeyFeatureFlagKeyDependentFlagsGet

MultiEnvironmentDependentFlags FlagsProjectKeyFeatureFlagKeyDependentFlagsGet (string projectKey, string featureFlagKey)

Get dependent flags across all environments for the flag specified in the path parameters

Example

using System;
using System.Diagnostics;
using LaunchDarkly.Api.Api;
using LaunchDarkly.Api.Client;
using LaunchDarkly.Api.Model;

namespace Example
{
    public class FlagsProjectKeyFeatureFlagKeyDependentFlagsGetExample
    {
        public void main()
        {
            
            // Configure API key authorization: Token
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new FeatureFlagsApi();
            var projectKey = projectKey_example;  // string | The project key, used to tie the flags together under one project so they can be managed together.
            var featureFlagKey = featureFlagKey_example;  // string | The feature flag's key. The key identifies the flag in your code.

            try
            {
                // Get dependent flags across all environments for the flag specified in the path parameters
                MultiEnvironmentDependentFlags result = apiInstance.FlagsProjectKeyFeatureFlagKeyDependentFlagsGet(projectKey, featureFlagKey);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FeatureFlagsApi.FlagsProjectKeyFeatureFlagKeyDependentFlagsGet: " + e.Message );
            }
        }
    }
}

Parameters

Name	Type	Description	Notes
projectKey	string	The project key, used to tie the flags together under one project so they can be managed together.
featureFlagKey	string	The feature flag's key. The key identifies the flag in your code.

Return type

MultiEnvironmentDependentFlags

Authorization

Token

HTTP request headers

• Content-Type: application/json
• Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

GetApprovalRequest

ApprovalRequests GetApprovalRequest (string projectKey, string featureFlagKey, string environmentKey, string approvalRequestId)

Get a single approval request for a feature flag config

Example

using System;
using System.Diagnostics;
using LaunchDarkly.Api.Api;
using LaunchDarkly.Api.Client;
using LaunchDarkly.Api.Model;

namespace Example
{
    public class GetApprovalRequestExample
    {
        public void main()
        {
            
            // Configure API key authorization: Token
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new FeatureFlagsApi();
            var projectKey = projectKey_example;  // string | The project key, used to tie the flags together under one project so they can be managed together.
            var featureFlagKey = featureFlagKey_example;  // string | The feature flag's key. The key identifies the flag in your code.
            var environmentKey = environmentKey_example;  // string | The environment key, used to tie together flag configuration and users under one environment so they can be managed together.
            var approvalRequestId = approvalRequestId_example;  // string | The approval request ID

            try
            {
                // Get a single approval request for a feature flag config
                ApprovalRequests result = apiInstance.GetApprovalRequest(projectKey, featureFlagKey, environmentKey, approvalRequestId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FeatureFlagsApi.GetApprovalRequest: " + e.Message );
            }
        }
    }
}

Parameters

Name	Type	Description	Notes
projectKey	string	The project key, used to tie the flags together under one project so they can be managed together.
featureFlagKey	string	The feature flag's key. The key identifies the flag in your code.
environmentKey	string	The environment key, used to tie together flag configuration and users under one environment so they can be managed together.
approvalRequestId	string	The approval request ID

Return type

ApprovalRequests

Authorization

Token

HTTP request headers

• Content-Type: application/json
• Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

GetApprovalRequests

ApprovalRequests GetApprovalRequests (string projectKey, string featureFlagKey, string environmentKey)

Get all approval requests for a feature flag config

Example

using System;
using System.Diagnostics;
using LaunchDarkly.Api.Api;
using LaunchDarkly.Api.Client;
using LaunchDarkly.Api.Model;

namespace Example
{
    public class GetApprovalRequestsExample
    {
        public void main()
        {
            
            // Configure API key authorization: Token
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new FeatureFlagsApi();
            var projectKey = projectKey_example;  // string | The project key, used to tie the flags together under one project so they can be managed together.
            var featureFlagKey = featureFlagKey_example;  // string | The feature flag's key. The key identifies the flag in your code.
            var environmentKey = environmentKey_example;  // string | The environment key, used to tie together flag configuration and users under one environment so they can be managed together.

            try
            {
                // Get all approval requests for a feature flag config
                ApprovalRequests result = apiInstance.GetApprovalRequests(projectKey, featureFlagKey, environmentKey);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FeatureFlagsApi.GetApprovalRequests: " + e.Message );
            }
        }
    }
}

Parameters

Name	Type	Description	Notes
projectKey	string	The project key, used to tie the flags together under one project so they can be managed together.
featureFlagKey	string	The feature flag's key. The key identifies the flag in your code.
environmentKey	string	The environment key, used to tie together flag configuration and users under one environment so they can be managed together.

Return type

ApprovalRequests

Authorization

Token

HTTP request headers

• Content-Type: application/json
• Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

GetExpiringUserTargets

UserTargetingExpirationForFlags GetExpiringUserTargets (string projectKey, string environmentKey, string featureFlagKey)

Get expiring user targets for feature flag

Example

using System;
using System.Diagnostics;
using LaunchDarkly.Api.Api;
using LaunchDarkly.Api.Client;
using LaunchDarkly.Api.Model;

namespace Example
{
    public class GetExpiringUserTargetsExample
    {
        public void main()
        {
            
            // Configure API key authorization: Token
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new FeatureFlagsApi();
            var projectKey = projectKey_example;  // string | The project key, used to tie the flags together under one project so they can be managed together.
            var environmentKey = environmentKey_example;  // string | The environment key, used to tie together flag configuration and users under one environment so they can be managed together.
            var featureFlagKey = featureFlagKey_example;  // string | The feature flag's key. The key identifies the flag in your code.

            try
            {
                // Get expiring user targets for feature flag
                UserTargetingExpirationForFlags result = apiInstance.GetExpiringUserTargets(projectKey, environmentKey, featureFlagKey);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FeatureFlagsApi.GetExpiringUserTargets: " + e.Message );
            }
        }
    }
}

Parameters

Name	Type	Description	Notes
projectKey	string	The project key, used to tie the flags together under one project so they can be managed together.
environmentKey	string	The environment key, used to tie together flag configuration and users under one environment so they can be managed together.
featureFlagKey	string	The feature flag's key. The key identifies the flag in your code.

Return type

UserTargetingExpirationForFlags

Authorization

Token

HTTP request headers

• Content-Type: application/json
• Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

GetFeatureFlag

FeatureFlag GetFeatureFlag (string projectKey, string featureFlagKey, List env)

Get a single feature flag by key.

Example

using System;
using System.Diagnostics;
using LaunchDarkly.Api.Api;
using LaunchDarkly.Api.Client;
using LaunchDarkly.Api.Model;

namespace Example
{
    public class GetFeatureFlagExample
    {
        public void main()
        {
            
            // Configure API key authorization: Token
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new FeatureFlagsApi();
            var projectKey = projectKey_example;  // string | The project key, used to tie the flags together under one project so they can be managed together.
            var featureFlagKey = featureFlagKey_example;  // string | The feature flag's key. The key identifies the flag in your code.
            var env = new List<string>(); // List<string> | By default, each feature will include configurations for each environment. You can filter environments with the env query parameter. For example, setting env=[\"production\"] will restrict the returned configurations to just your production environment. (optional) 

            try
            {
                // Get a single feature flag by key.
                FeatureFlag result = apiInstance.GetFeatureFlag(projectKey, featureFlagKey, env);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FeatureFlagsApi.GetFeatureFlag: " + e.Message );
            }
        }
    }
}

Parameters

Name	Type	Description	Notes
projectKey	string	The project key, used to tie the flags together under one project so they can be managed together.
featureFlagKey	string	The feature flag's key. The key identifies the flag in your code.
env	List	By default, each feature will include configurations for each environment. You can filter environments with the env query parameter. For example, setting env=["production"] will restrict the returned configurations to just your production environment.	[optional]

Return type

FeatureFlag

Authorization

Token

HTTP request headers

• Content-Type: application/json
• Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

GetFeatureFlagStatus

FeatureFlagStatus GetFeatureFlagStatus (string projectKey, string environmentKey, string featureFlagKey)

Get the status for a particular feature flag.

Example

using System;
using System.Diagnostics;
using LaunchDarkly.Api.Api;
using LaunchDarkly.Api.Client;
using LaunchDarkly.Api.Model;

namespace Example
{
    public class GetFeatureFlagStatusExample
    {
        public void main()
        {
            
            // Configure API key authorization: Token
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new FeatureFlagsApi();
            var projectKey = projectKey_example;  // string | The project key, used to tie the flags together under one project so they can be managed together.
            var environmentKey = environmentKey_example;  // string | The environment key, used to tie together flag configuration and users under one environment so they can be managed together.
            var featureFlagKey = featureFlagKey_example;  // string | The feature flag's key. The key identifies the flag in your code.

            try
            {
                // Get the status for a particular feature flag.
                FeatureFlagStatus result = apiInstance.GetFeatureFlagStatus(projectKey, environmentKey, featureFlagKey);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FeatureFlagsApi.GetFeatureFlagStatus: " + e.Message );
            }
        }
    }
}

Parameters

Name	Type	Description	Notes
projectKey	string	The project key, used to tie the flags together under one project so they can be managed together.
environmentKey	string	The environment key, used to tie together flag configuration and users under one environment so they can be managed together.
featureFlagKey	string	The feature flag's key. The key identifies the flag in your code.

Return type

FeatureFlagStatus

Authorization

Token

HTTP request headers

• Content-Type: application/json
• Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

GetFeatureFlagStatusAcrossEnvironments

FeatureFlagStatusAcrossEnvironments GetFeatureFlagStatusAcrossEnvironments (string projectKey, string featureFlagKey)

Get the status for a particular feature flag across environments

Example

using System;
using System.Diagnostics;
using LaunchDarkly.Api.Api;
using LaunchDarkly.Api.Client;
using LaunchDarkly.Api.Model;

namespace Example
{
    public class GetFeatureFlagStatusAcrossEnvironmentsExample
    {
        public void main()
        {
            
            // Configure API key authorization: Token
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new FeatureFlagsApi();
            var projectKey = projectKey_example;  // string | The project key, used to tie the flags together under one project so they can be managed together.
            var featureFlagKey = featureFlagKey_example;  // string | The feature flag's key. The key identifies the flag in your code.

            try
            {
                // Get the status for a particular feature flag across environments
                FeatureFlagStatusAcrossEnvironments result = apiInstance.GetFeatureFlagStatusAcrossEnvironments(projectKey, featureFlagKey);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FeatureFlagsApi.GetFeatureFlagStatusAcrossEnvironments: " + e.Message );
            }
        }
    }
}

Parameters

Name	Type	Description	Notes
projectKey	string	The project key, used to tie the flags together under one project so they can be managed together.
featureFlagKey	string	The feature flag's key. The key identifies the flag in your code.

Return type

FeatureFlagStatusAcrossEnvironments

Authorization

Token

HTTP request headers

• Content-Type: application/json
• Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

GetFeatureFlagStatuses

FeatureFlagStatuses GetFeatureFlagStatuses (string projectKey, string environmentKey)

Get a list of statuses for all feature flags. The status includes the last time the feature flag was requested, as well as the state of the flag.

Example

using System;
using System.Diagnostics;
using LaunchDarkly.Api.Api;
using LaunchDarkly.Api.Client;
using LaunchDarkly.Api.Model;

namespace Example
{
    public class GetFeatureFlagStatusesExample
    {
        public void main()
        {
            
            // Configure API key authorization: Token
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new FeatureFlagsApi();
            var projectKey = projectKey_example;  // string | The project key, used to tie the flags together under one project so they can be managed together.
            var environmentKey = environmentKey_example;  // string | The environment key, used to tie together flag configuration and users under one environment so they can be managed together.

            try
            {
                // Get a list of statuses for all feature flags. The status includes the last time the feature flag was requested, as well as the state of the flag.
                FeatureFlagStatuses result = apiInstance.GetFeatureFlagStatuses(projectKey, environmentKey);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FeatureFlagsApi.GetFeatureFlagStatuses: " + e.Message );
            }
        }
    }
}

Parameters

Name	Type	Description	Notes
projectKey	string	The project key, used to tie the flags together under one project so they can be managed together.
environmentKey	string	The environment key, used to tie together flag configuration and users under one environment so they can be managed together.

Return type

FeatureFlagStatuses

Authorization

Token

HTTP request headers

• Content-Type: application/json
• Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

GetFeatureFlags

FeatureFlags GetFeatureFlags (string projectKey, List env, bool? summary, bool? archived, decimal? limit, decimal? offset, string filter, string sort, string tag)

Get a list of all features in the given project.

Example

using System;
using System.Diagnostics;
using LaunchDarkly.Api.Api;
using LaunchDarkly.Api.Client;
using LaunchDarkly.Api.Model;

namespace Example
{
    public class GetFeatureFlagsExample
    {
        public void main()
        {
            
            // Configure API key authorization: Token
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new FeatureFlagsApi();
            var projectKey = projectKey_example;  // string | The project key, used to tie the flags together under one project so they can be managed together.
            var env = new List<string>(); // List<string> | By default, each feature will include configurations for each environment. You can filter environments with the env query parameter. For example, setting env=[\"production\"] will restrict the returned configurations to just your production environment. (optional) 
            var summary = true;  // bool? | By default in api version >= 1, flags will _not_ include their list of prerequisites, targets or rules.  Set summary=0 to include these fields for each flag returned. (optional) 
            var archived = true;  // bool? | When set to 1, only archived flags will be included in the list of flags returned.  By default, archived flags are not included in the list of flags. (optional) 
            var limit = 8.14;  // decimal? | The number of objects to return. Defaults to -1, which returns everything. (optional) 
            var offset = 8.14;  // decimal? | Where to start in the list. This is for use with pagination. For example, an offset of 10 would skip the first 10 items and then return the next limit items. (optional) 
            var filter = filter_example;  // string | A comma-separated list of filters. Each filter is of the form field:value. (optional) 
            var sort = sort_example;  // string | A comma-separated list of fields to sort by. A field prefixed by a - will be sorted in descending order. (optional) 
            var tag = tag_example;  // string | Filter by tag. A tag can be used to group flags across projects. (optional) 

            try
            {
                // Get a list of all features in the given project.
                FeatureFlags result = apiInstance.GetFeatureFlags(projectKey, env, summary, archived, limit, offset, filter, sort, tag);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FeatureFlagsApi.GetFeatureFlags: " + e.Message );
            }
        }
    }
}

Parameters

Name	Type	Description	Notes
projectKey	string	The project key, used to tie the flags together under one project so they can be managed together.
env	List	By default, each feature will include configurations for each environment. You can filter environments with the env query parameter. For example, setting env=["production"] will restrict the returned configurations to just your production environment.	[optional]
summary	bool?	By default in api version >= 1, flags will not include their list of prerequisites, targets or rules. Set summary=0 to include these fields for each flag returned.	[optional]
archived	bool?	When set to 1, only archived flags will be included in the list of flags returned. By default, archived flags are not included in the list of flags.	[optional]
limit	decimal?	The number of objects to return. Defaults to -1, which returns everything.	[optional]
offset	decimal?	Where to start in the list. This is for use with pagination. For example, an offset of 10 would skip the first 10 items and then return the next limit items.	[optional]
filter	string	A comma-separated list of filters. Each filter is of the form field:value.	[optional]
sort	string	A comma-separated list of fields to sort by. A field prefixed by a - will be sorted in descending order.	[optional]
tag	string	Filter by tag. A tag can be used to group flags across projects.	[optional]

Return type

FeatureFlags

Authorization

Token

HTTP request headers

• Content-Type: application/json
• Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

GetFlagConfigScheduledChange

FeatureFlagScheduledChange GetFlagConfigScheduledChange (string projectKey, string featureFlagKey, string environmentKey, string scheduledChangeId)

Get a scheduled change on a feature flag by id.

Example

using System;
using System.Diagnostics;
using LaunchDarkly.Api.Api;
using LaunchDarkly.Api.Client;
using LaunchDarkly.Api.Model;

namespace Example
{
    public class GetFlagConfigScheduledChangeExample
    {
        public void main()
        {
            
            // Configure API key authorization: Token
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new FeatureFlagsApi();
            var projectKey = projectKey_example;  // string | The project key, used to tie the flags together under one project so they can be managed together.
            var featureFlagKey = featureFlagKey_example;  // string | The feature flag's key. The key identifies the flag in your code.
            var environmentKey = environmentKey_example;  // string | The environment key, used to tie together flag configuration and users under one environment so they can be managed together.
            var scheduledChangeId = scheduledChangeId_example;  // string | The id of the scheduled change

            try
            {
                // Get a scheduled change on a feature flag by id.
                FeatureFlagScheduledChange result = apiInstance.GetFlagConfigScheduledChange(projectKey, featureFlagKey, environmentKey, scheduledChangeId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FeatureFlagsApi.GetFlagConfigScheduledChange: " + e.Message );
            }
        }
    }
}

Parameters

Name	Type	Description	Notes
projectKey	string	The project key, used to tie the flags together under one project so they can be managed together.
featureFlagKey	string	The feature flag's key. The key identifies the flag in your code.
environmentKey	string	The environment key, used to tie together flag configuration and users under one environment so they can be managed together.
scheduledChangeId	string	The id of the scheduled change

Return type

FeatureFlagScheduledChange

Authorization

Token

HTTP request headers

• Content-Type: application/json
• Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

GetFlagConfigScheduledChanges

FeatureFlagScheduledChanges GetFlagConfigScheduledChanges (string projectKey, string featureFlagKey, string environmentKey)

Get all scheduled workflows for a feature flag by key.

Example

using System;
using System.Diagnostics;
using LaunchDarkly.Api.Api;
using LaunchDarkly.Api.Client;
using LaunchDarkly.Api.Model;

namespace Example
{
    public class GetFlagConfigScheduledChangesExample
    {
        public void main()
        {
            
            // Configure API key authorization: Token
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new FeatureFlagsApi();
            var projectKey = projectKey_example;  // string | The project key, used to tie the flags together under one project so they can be managed together.
            var featureFlagKey = featureFlagKey_example;  // string | The feature flag's key. The key identifies the flag in your code.
            var environmentKey = environmentKey_example;  // string | The environment key, used to tie together flag configuration and users under one environment so they can be managed together.

            try
            {
                // Get all scheduled workflows for a feature flag by key.
                FeatureFlagScheduledChanges result = apiInstance.GetFlagConfigScheduledChanges(projectKey, featureFlagKey, environmentKey);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FeatureFlagsApi.GetFlagConfigScheduledChanges: " + e.Message );
            }
        }
    }
}

Parameters

Name	Type	Description	Notes
projectKey	string	The project key, used to tie the flags together under one project so they can be managed together.
featureFlagKey	string	The feature flag's key. The key identifies the flag in your code.
environmentKey	string	The environment key, used to tie together flag configuration and users under one environment so they can be managed together.

Return type

FeatureFlagScheduledChanges

Authorization

Token

HTTP request headers

• Content-Type: application/json
• Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

GetFlagConfigScheduledChangesConflicts

FeatureFlagScheduledChangesConflicts GetFlagConfigScheduledChangesConflicts (string projectKey, string featureFlagKey, string environmentKey, FlagConfigScheduledChangesConflictsBody flagConfigScheduledChangesConflictsBody)

Lists conflicts between the given instructions and any existing scheduled changes for the feature flag. The actual HTTP verb should be REPORT, not POST.

Example

using System;
using System.Diagnostics;
using LaunchDarkly.Api.Api;
using LaunchDarkly.Api.Client;
using LaunchDarkly.Api.Model;

namespace Example
{
    public class GetFlagConfigScheduledChangesConflictsExample
    {
        public void main()
        {
            
            // Configure API key authorization: Token
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new FeatureFlagsApi();
            var projectKey = projectKey_example;  // string | The project key, used to tie the flags together under one project so they can be managed together.
            var featureFlagKey = featureFlagKey_example;  // string | The feature flag's key. The key identifies the flag in your code.
            var environmentKey = environmentKey_example;  // string | The environment key, used to tie together flag configuration and users under one environment so they can be managed together.
            var flagConfigScheduledChangesConflictsBody = new FlagConfigScheduledChangesConflictsBody(); // FlagConfigScheduledChangesConflictsBody | Used to determine if a semantic patch will result in conflicts with scheduled changes on a feature flag.

            try
            {
                // Lists conflicts between the given instructions and any existing scheduled changes for the feature flag. The actual HTTP verb should be REPORT, not POST.
                FeatureFlagScheduledChangesConflicts result = apiInstance.GetFlagConfigScheduledChangesConflicts(projectKey, featureFlagKey, environmentKey, flagConfigScheduledChangesConflictsBody);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FeatureFlagsApi.GetFlagConfigScheduledChangesConflicts: " + e.Message );
            }
        }
    }
}

Parameters

Name	Type	Description	Notes
projectKey	string	The project key, used to tie the flags together under one project so they can be managed together.
featureFlagKey	string	The feature flag's key. The key identifies the flag in your code.
environmentKey	string	The environment key, used to tie together flag configuration and users under one environment so they can be managed together.
flagConfigScheduledChangesConflictsBody	FlagConfigScheduledChangesConflictsBody	Used to determine if a semantic patch will result in conflicts with scheduled changes on a feature flag.

Return type

FeatureFlagScheduledChangesConflicts

Authorization

Token

HTTP request headers

• Content-Type: application/json
• Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

PatchExpiringUserTargets

UserTargetingExpirationForFlags PatchExpiringUserTargets (string projectKey, string environmentKey, string featureFlagKey, Object semanticPatchWithComment)

Update, add, or delete expiring user targets on feature flag

Example

using System;
using System.Diagnostics;
using LaunchDarkly.Api.Api;
using LaunchDarkly.Api.Client;
using LaunchDarkly.Api.Model;

namespace Example
{
    public class PatchExpiringUserTargetsExample
    {
        public void main()
        {
            
            // Configure API key authorization: Token
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new FeatureFlagsApi();
            var projectKey = projectKey_example;  // string | The project key, used to tie the flags together under one project so they can be managed together.
            var environmentKey = environmentKey_example;  // string | The environment key, used to tie together flag configuration and users under one environment so they can be managed together.
            var featureFlagKey = featureFlagKey_example;  // string | The feature flag's key. The key identifies the flag in your code.
            var semanticPatchWithComment = ;  // Object | Requires a Semantic Patch representation of the desired changes to the resource. 'https://apidocs.launchdarkly.com/reference#updates-via-semantic-patches'. The addition of comments is also supported.

            try
            {
                // Update, add, or delete expiring user targets on feature flag
                UserTargetingExpirationForFlags result = apiInstance.PatchExpiringUserTargets(projectKey, environmentKey, featureFlagKey, semanticPatchWithComment);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FeatureFlagsApi.PatchExpiringUserTargets: " + e.Message );
            }
        }
    }
}

Parameters

Name	Type	Description	Notes
projectKey	string	The project key, used to tie the flags together under one project so they can be managed together.
environmentKey	string	The environment key, used to tie together flag configuration and users under one environment so they can be managed together.
featureFlagKey	string	The feature flag's key. The key identifies the flag in your code.
semanticPatchWithComment	Object	Requires a Semantic Patch representation of the desired changes to the resource. 'https://apidocs.launchdarkly.com/reference#updates-via-semantic-patches'. The addition of comments is also supported.

Return type

UserTargetingExpirationForFlags

Authorization

Token

HTTP request headers

• Content-Type: application/json
• Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

PatchFeatureFlag

FeatureFlag PatchFeatureFlag (string projectKey, string featureFlagKey, PatchComment patchComment)

Perform a partial update to a feature.

Example

using System;
using System.Diagnostics;
using LaunchDarkly.Api.Api;
using LaunchDarkly.Api.Client;
using LaunchDarkly.Api.Model;

namespace Example
{
    public class PatchFeatureFlagExample
    {
        public void main()
        {
            
            // Configure API key authorization: Token
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new FeatureFlagsApi();
            var projectKey = projectKey_example;  // string | The project key, used to tie the flags together under one project so they can be managed together.
            var featureFlagKey = featureFlagKey_example;  // string | The feature flag's key. The key identifies the flag in your code.
            var patchComment = new PatchComment(); // PatchComment | Requires a JSON Patch representation of the desired changes to the project, and an optional comment. 'http://jsonpatch.com/' Feature flag patches also support JSON Merge Patch format. 'https://tools.ietf.org/html/rfc7386' The addition of comments is also supported.

            try
            {
                // Perform a partial update to a feature.
                FeatureFlag result = apiInstance.PatchFeatureFlag(projectKey, featureFlagKey, patchComment);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FeatureFlagsApi.PatchFeatureFlag: " + e.Message );
            }
        }
    }
}

Parameters

Name	Type	Description	Notes
projectKey	string	The project key, used to tie the flags together under one project so they can be managed together.
featureFlagKey	string	The feature flag's key. The key identifies the flag in your code.
patchComment	PatchComment	Requires a JSON Patch representation of the desired changes to the project, and an optional comment. 'http://jsonpatch.com/' Feature flag patches also support JSON Merge Patch format. 'https://tools.ietf.org/html/rfc7386' The addition of comments is also supported.

Return type

FeatureFlag

Authorization

Token

HTTP request headers

• Content-Type: application/json
• Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

PatchFlagConfigScheduledChange

FeatureFlagScheduledChange PatchFlagConfigScheduledChange (string projectKey, string featureFlagKey, FlagConfigScheduledChangesPatchBody flagConfigScheduledChangesPatchBody, string environmentKey, string scheduledChangeId)

Updates an existing scheduled-change on a feature flag in an environment.

Example

using System;
using System.Diagnostics;
using LaunchDarkly.Api.Api;
using LaunchDarkly.Api.Client;
using LaunchDarkly.Api.Model;

namespace Example
{
    public class PatchFlagConfigScheduledChangeExample
    {
        public void main()
        {
            
            // Configure API key authorization: Token
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new FeatureFlagsApi();
            var projectKey = projectKey_example;  // string | The project key, used to tie the flags together under one project so they can be managed together.
            var featureFlagKey = featureFlagKey_example;  // string | The feature flag's key. The key identifies the flag in your code.
            var flagConfigScheduledChangesPatchBody = new FlagConfigScheduledChangesPatchBody(); // FlagConfigScheduledChangesPatchBody | Update scheduled changes on a feature flag.
            var environmentKey = environmentKey_example;  // string | The environment key, used to tie together flag configuration and users under one environment so they can be managed together.
            var scheduledChangeId = scheduledChangeId_example;  // string | The id of the scheduled change

            try
            {
                // Updates an existing scheduled-change on a feature flag in an environment.
                FeatureFlagScheduledChange result = apiInstance.PatchFlagConfigScheduledChange(projectKey, featureFlagKey, flagConfigScheduledChangesPatchBody, environmentKey, scheduledChangeId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FeatureFlagsApi.PatchFlagConfigScheduledChange: " + e.Message );
            }
        }
    }
}

Parameters

Name	Type	Description	Notes
projectKey	string	The project key, used to tie the flags together under one project so they can be managed together.
featureFlagKey	string	The feature flag's key. The key identifies the flag in your code.
flagConfigScheduledChangesPatchBody	FlagConfigScheduledChangesPatchBody	Update scheduled changes on a feature flag.
environmentKey	string	The environment key, used to tie together flag configuration and users under one environment so they can be managed together.
scheduledChangeId	string	The id of the scheduled change

Return type

FeatureFlagScheduledChange

Authorization

Token

HTTP request headers

• Content-Type: application/json
• Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

PostApplyApprovalRequest

ApprovalRequests PostApplyApprovalRequest (string projectKey, string featureFlagKey, string environmentKey, string approvalRequestId, ApprovalRequestApplyConfigBody approvalRequestApplyConfigBody)

Apply approval request for a feature flag config

Example

using System;
using System.Diagnostics;
using LaunchDarkly.Api.Api;
using LaunchDarkly.Api.Client;
using LaunchDarkly.Api.Model;

namespace Example
{
    public class PostApplyApprovalRequestExample
    {
        public void main()
        {
            
            // Configure API key authorization: Token
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new FeatureFlagsApi();
            var projectKey = projectKey_example;  // string | The project key, used to tie the flags together under one project so they can be managed together.
            var featureFlagKey = featureFlagKey_example;  // string | The feature flag's key. The key identifies the flag in your code.
            var environmentKey = environmentKey_example;  // string | The environment key, used to tie together flag configuration and users under one environment so they can be managed together.
            var approvalRequestId = approvalRequestId_example;  // string | The approval request ID
            var approvalRequestApplyConfigBody = new ApprovalRequestApplyConfigBody(); // ApprovalRequestApplyConfigBody | Apply an approval request

            try
            {
                // Apply approval request for a feature flag config
                ApprovalRequests result = apiInstance.PostApplyApprovalRequest(projectKey, featureFlagKey, environmentKey, approvalRequestId, approvalRequestApplyConfigBody);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FeatureFlagsApi.PostApplyApprovalRequest: " + e.Message );
            }
        }
    }
}

Parameters

Name	Type	Description	Notes
projectKey	string	The project key, used to tie the flags together under one project so they can be managed together.
featureFlagKey	string	The feature flag's key. The key identifies the flag in your code.
environmentKey	string	The environment key, used to tie together flag configuration and users under one environment so they can be managed together.
approvalRequestId	string	The approval request ID
approvalRequestApplyConfigBody	ApprovalRequestApplyConfigBody	Apply an approval request

Return type

ApprovalRequests

Authorization

Token

HTTP request headers

• Content-Type: application/json
• Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

PostApprovalRequest

ApprovalRequest PostApprovalRequest (string projectKey, string featureFlagKey, string environmentKey, string approvalRequestId, ApprovalRequestConfigBody approvalRequestConfigBody)

Create an approval request for a feature flag config

Example

using System;
using System.Diagnostics;
using LaunchDarkly.Api.Api;
using LaunchDarkly.Api.Client;
using LaunchDarkly.Api.Model;

namespace Example
{
    public class PostApprovalRequestExample
    {
        public void main()
        {
            
            // Configure API key authorization: Token
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new FeatureFlagsApi();
            var projectKey = projectKey_example;  // string | The project key, used to tie the flags together under one project so they can be managed together.
            var featureFlagKey = featureFlagKey_example;  // string | The feature flag's key. The key identifies the flag in your code.
            var environmentKey = environmentKey_example;  // string | The environment key, used to tie together flag configuration and users under one environment so they can be managed together.
            var approvalRequestId = approvalRequestId_example;  // string | The approval request ID
            var approvalRequestConfigBody = new ApprovalRequestConfigBody(); // ApprovalRequestConfigBody | Create a new approval request (optional) 

            try
            {
                // Create an approval request for a feature flag config
                ApprovalRequest result = apiInstance.PostApprovalRequest(projectKey, featureFlagKey, environmentKey, approvalRequestId, approvalRequestConfigBody);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FeatureFlagsApi.PostApprovalRequest: " + e.Message );
            }
        }
    }
}

Parameters

Name	Type	Description	Notes
projectKey	string	The project key, used to tie the flags together under one project so they can be managed together.
featureFlagKey	string	The feature flag's key. The key identifies the flag in your code.
environmentKey	string	The environment key, used to tie together flag configuration and users under one environment so they can be managed together.
approvalRequestId	string	The approval request ID
approvalRequestConfigBody	ApprovalRequestConfigBody	Create a new approval request	[optional]

Return type

ApprovalRequest

Authorization

Token

HTTP request headers

• Content-Type: application/json
• Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

PostFeatureFlag

FeatureFlag PostFeatureFlag (string projectKey, FeatureFlagBody featureFlagBody, string clone)

Creates a new feature flag.

Example

using System;
using System.Diagnostics;
using LaunchDarkly.Api.Api;
using LaunchDarkly.Api.Client;
using LaunchDarkly.Api.Model;

namespace Example
{
    public class PostFeatureFlagExample
    {
        public void main()
        {
            
            // Configure API key authorization: Token
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new FeatureFlagsApi();
            var projectKey = projectKey_example;  // string | The project key, used to tie the flags together under one project so they can be managed together.
            var featureFlagBody = new FeatureFlagBody(); // FeatureFlagBody | Create a new feature flag.
            var clone = clone_example;  // string | The key of the feature flag to be cloned. The key identifies the flag in your code.  For example, setting clone=flagKey will copy the full targeting configuration for all environments (including on/off state) from the original flag to the new flag. (optional) 

            try
            {
                // Creates a new feature flag.
                FeatureFlag result = apiInstance.PostFeatureFlag(projectKey, featureFlagBody, clone);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FeatureFlagsApi.PostFeatureFlag: " + e.Message );
            }
        }
    }
}

Parameters

Name	Type	Description	Notes
projectKey	string	The project key, used to tie the flags together under one project so they can be managed together.
featureFlagBody	FeatureFlagBody	Create a new feature flag.
clone	string	The key of the feature flag to be cloned. The key identifies the flag in your code. For example, setting clone=flagKey will copy the full targeting configuration for all environments (including on/off state) from the original flag to the new flag.	[optional]

Return type

FeatureFlag

Authorization

Token

HTTP request headers

• Content-Type: application/json
• Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

PostFlagConfigScheduledChanges

FeatureFlagScheduledChange PostFlagConfigScheduledChanges (string projectKey, FlagConfigScheduledChangesPostBody flagConfigScheduledChangesPostBody, string featureFlagKey, string environmentKey)

Creates a new scheduled change for a feature flag.

Example

using System;
using System.Diagnostics;
using LaunchDarkly.Api.Api;
using LaunchDarkly.Api.Client;
using LaunchDarkly.Api.Model;

namespace Example
{
    public class PostFlagConfigScheduledChangesExample
    {
        public void main()
        {
            
            // Configure API key authorization: Token
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new FeatureFlagsApi();
            var projectKey = projectKey_example;  // string | The project key, used to tie the flags together under one project so they can be managed together.
            var flagConfigScheduledChangesPostBody = new FlagConfigScheduledChangesPostBody(); // FlagConfigScheduledChangesPostBody | Create scheduled changes on a feature flag.
            var featureFlagKey = featureFlagKey_example;  // string | The feature flag's key. The key identifies the flag in your code.
            var environmentKey = environmentKey_example;  // string | The environment key, used to tie together flag configuration and users under one environment so they can be managed together.

            try
            {
                // Creates a new scheduled change for a feature flag.
                FeatureFlagScheduledChange result = apiInstance.PostFlagConfigScheduledChanges(projectKey, flagConfigScheduledChangesPostBody, featureFlagKey, environmentKey);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FeatureFlagsApi.PostFlagConfigScheduledChanges: " + e.Message );
            }
        }
    }
}

Parameters

Name	Type	Description	Notes
projectKey	string	The project key, used to tie the flags together under one project so they can be managed together.
flagConfigScheduledChangesPostBody	FlagConfigScheduledChangesPostBody	Create scheduled changes on a feature flag.
featureFlagKey	string	The feature flag's key. The key identifies the flag in your code.
environmentKey	string	The environment key, used to tie together flag configuration and users under one environment so they can be managed together.

Return type

FeatureFlagScheduledChange

Authorization

Token

HTTP request headers

• Content-Type: application/json
• Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

PostReviewApprovalRequest

ApprovalRequests PostReviewApprovalRequest (string projectKey, string featureFlagKey, string environmentKey, string approvalRequestId, ApprovalRequestReviewConfigBody approvalRequestReviewConfigBody)

Review approval request for a feature flag config

Example

using System;
using System.Diagnostics;
using LaunchDarkly.Api.Api;
using LaunchDarkly.Api.Client;
using LaunchDarkly.Api.Model;

namespace Example
{
    public class PostReviewApprovalRequestExample
    {
        public void main()
        {
            
            // Configure API key authorization: Token
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new FeatureFlagsApi();
            var projectKey = projectKey_example;  // string | The project key, used to tie the flags together under one project so they can be managed together.
            var featureFlagKey = featureFlagKey_example;  // string | The feature flag's key. The key identifies the flag in your code.
            var environmentKey = environmentKey_example;  // string | The environment key, used to tie together flag configuration and users under one environment so they can be managed together.
            var approvalRequestId = approvalRequestId_example;  // string | The approval request ID
            var approvalRequestReviewConfigBody = new ApprovalRequestReviewConfigBody(); // ApprovalRequestReviewConfigBody | Review an approval request

            try
            {
                // Review approval request for a feature flag config
                ApprovalRequests result = apiInstance.PostReviewApprovalRequest(projectKey, featureFlagKey, environmentKey, approvalRequestId, approvalRequestReviewConfigBody);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FeatureFlagsApi.PostReviewApprovalRequest: " + e.Message );
            }
        }
    }
}

Parameters

Name	Type	Description	Notes
projectKey	string	The project key, used to tie the flags together under one project so they can be managed together.
featureFlagKey	string	The feature flag's key. The key identifies the flag in your code.
environmentKey	string	The environment key, used to tie together flag configuration and users under one environment so they can be managed together.
approvalRequestId	string	The approval request ID
approvalRequestReviewConfigBody	ApprovalRequestReviewConfigBody	Review an approval request

Return type

ApprovalRequests

Authorization

Token

HTTP request headers

• Content-Type: application/json
• Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]