import type { CommonClientOptions } from '@azure/core-client';
import type { CompatResponse } from '@azure/core-http-compat';
import type { OperationOptions } from '@azure/core-client';
import type { OperationState } from '@azure/core-lro';
import type { PagedAsyncIterableIterator } from '@azure/core-paging';
import type { SimplePollerLike } from '@azure/core-lro';
import type { TokenCredential } from '@azure/core-auth';

/**
 * Options used when adding a ConfigurationSetting.
 */
export declare interface AddConfigurationSettingOptions extends OperationOptions {
}

/**
 * Parameters for adding a new configuration setting
 */
export declare type AddConfigurationSettingParam<T extends string | FeatureFlagValue | SecretReferenceValue = string> = ConfigurationSettingParam<T>;

/**
 * Response from adding a ConfigurationSetting.
 */
export declare interface AddConfigurationSettingResponse extends ConfigurationSetting, SyncTokenHeaderField, HttpResponseField<SyncTokenHeaderField> {
}

/**
 * Client for the Azure App Configuration service.
 */
export declare class AppConfigurationClient {
    private client;
    private _syncTokens;
    /**
     * Initializes a new instance of the AppConfigurationClient class.
     * @param connectionString - Connection string needed for a client to connect to Azure.
     * @param options - Options for the AppConfigurationClient.
     */
    constructor(connectionString: string, options?: AppConfigurationClientOptions);
    /**
     * Initializes a new instance of the AppConfigurationClient class using
     * a TokenCredential.
     * @param endpoint - The endpoint of the App Configuration service (ex: https://sample.azconfig.io).
     * @param tokenCredential - An object that implements the `TokenCredential` interface used to authenticate requests to the service. Use the \@azure/identity package to create a credential that suits your needs.
     * @param options - Options for the AppConfigurationClient.
     */
    constructor(endpoint: string, tokenCredential: TokenCredential, options?: AppConfigurationClientOptions);
    /**
     * Add a setting into the Azure App Configuration service, failing if it
     * already exists.
     *
     * Example usage:
     * ```ts
     * const result = await client.addConfigurationSetting({ key: "MyKey", label: "MyLabel", value: "MyValue" });
     * ```
     * @param configurationSetting - A configuration setting.
     * @param options - Optional parameters for the request.
     */
    addConfigurationSetting(configurationSetting: AddConfigurationSettingParam | AddConfigurationSettingParam<FeatureFlagValue> | AddConfigurationSettingParam<SecretReferenceValue>, options?: AddConfigurationSettingOptions): Promise<AddConfigurationSettingResponse>;
    /**
     * Delete a setting from the Azure App Configuration service
     *
     * Example usage:
     * ```ts
     * const deletedSetting = await client.deleteConfigurationSetting({ key: "MyKey", label: "MyLabel" });
     * ```
     * @param id - The id of the configuration setting to delete.
     * @param options - Optional parameters for the request (ex: etag, label)
     */
    deleteConfigurationSetting(id: ConfigurationSettingId, options?: DeleteConfigurationSettingOptions): Promise<DeleteConfigurationSettingResponse>;
    /**
     * Gets a setting from the Azure App Configuration service.
     *
     * Example code:
     * ```ts
     * const setting = await client.getConfigurationSetting({ key: "MyKey", label: "MyLabel" });
     * ```
     * @param id - The id of the configuration setting to get.
     * @param options - Optional parameters for the request.
     */
    getConfigurationSetting(id: ConfigurationSettingId, options?: GetConfigurationSettingOptions): Promise<GetConfigurationSettingResponse>;
    /**
     * Lists settings from the Azure App Configuration service, optionally
     * filtered by key names, labels and accept datetime.
     *
     * Example code:
     * ```ts
     * const allSettingsWithLabel = client.listConfigurationSettings({ labelFilter: "MyLabel" });
     * ```
     * @param options - Optional parameters for the request.
     */
    listConfigurationSettings(options?: ListConfigurationSettingsOptions): PagedAsyncIterableIterator<ConfigurationSetting, ListConfigurationSettingPage, PageSettings>;
    /**
     * Lists settings from the Azure App Configuration service for snapshots based on name, optionally
     * filtered by key names, labels and accept datetime.
     *
     * Example code:
     * ```ts
     * const allSettingsWithLabel = client.listConfigurationSettingsForSnashots({ snapshotName: "MySnapshot" });
     * ```
     * @param options - Optional parameters for the request.
     */
    listConfigurationSettingsForSnapshot(snapshotName: string, options?: ListConfigurationSettingsForSnapshotOptions): PagedAsyncIterableIterator<ConfigurationSetting, ListConfigurationSettingPage, PageSettings>;
    /**
     * Get a list of labels from the Azure App Configuration service
     *
     * Example code:
     * ```ts
     * const allSettingsWithLabel = client.listLabels({ nameFilter: "prod*" });
     * ```
     * @param options - Optional parameters for the request.
     */
    listLabels(options?: ListLabelsOptions): PagedAsyncIterableIterator<SettingLabel, ListLabelsPage, PageSettings>;
    private sendLabelsRequest;
    private sendConfigurationSettingsRequest;
    /**
     * Lists revisions of a set of keys, optionally filtered by key names,
     * labels and accept datetime.
     *
     * Example code:
     * ```ts
     * const revisionsIterator = client.listRevisions({ keys: ["MyKey"] });
     * ```
     * @param options - Optional parameters for the request.
     */
    listRevisions(options?: ListRevisionsOptions): PagedAsyncIterableIterator<ConfigurationSetting, ListRevisionsPage, PageSettings>;
    private sendRevisionsRequest;
    /**
     * Sets the value of a key in the Azure App Configuration service, allowing for an optional etag.
     * @param key - The name of the key.
     * @param configurationSetting - A configuration value.
     * @param options - Optional parameters for the request.
     *
     * Example code:
     * ```ts
     * await client.setConfigurationSetting({ key: "MyKey", value: "MyValue" });
     * ```
     */
    setConfigurationSetting(configurationSetting: SetConfigurationSettingParam | SetConfigurationSettingParam<FeatureFlagValue> | SetConfigurationSettingParam<SecretReferenceValue>, options?: SetConfigurationSettingOptions): Promise<SetConfigurationSettingResponse>;
    /**
     * Sets or clears a key's read-only status.
     * @param id - The id of the configuration setting to modify.
     */
    setReadOnly(id: ConfigurationSettingId, readOnly: boolean, options?: SetReadOnlyOptions): Promise<SetReadOnlyResponse>;
    /**
     * Adds an external synchronization token to ensure service requests receive up-to-date values.
     *
     * @param syncToken - The synchronization token value.
     */
    updateSyncToken(syncToken: string): void;
    /**
     * Begins creating a snapshot for Azure App Configuration service, fails if it
     * already exists.
     */
    beginCreateSnapshot(snapshot: SnapshotInfo, options?: CreateSnapshotOptions): Promise<SimplePollerLike<OperationState<CreateSnapshotResponse>, CreateSnapshotResponse>>;
    /**
     * Begins creating a snapshot for Azure App Configuration service, waits until it is done,
     * fails if it already exists.
     */
    beginCreateSnapshotAndWait(snapshot: SnapshotInfo, options?: CreateSnapshotOptions): Promise<CreateSnapshotResponse>;
    /**
     * Get a snapshot from Azure App Configuration service
     *
     * Example usage:
     * ```ts
     * const result = await client.getSnapshot("MySnapshot");
     * ```
     * @param name - The name of the snapshot.
     * @param options - Optional parameters for the request.
     */
    getSnapshot(name: string, options?: GetSnapshotOptions): Promise<GetSnapshotResponse>;
    /**
     * Recover an archived snapshot back to ready status
     *
     * Example usage:
     * ```ts
     * const result = await client.recoverSnapshot("MySnapshot");
     * ```
     * @param name - The name of the snapshot.
     * @param options - Optional parameters for the request.
     */
    recoverSnapshot(name: string, options?: UpdateSnapshotOptions): Promise<UpdateSnapshotResponse>;
    /**
     * Archive a ready snapshot
     *
     * Example usage:
     * ```ts
     * const result = await client.archiveSnapshot({name: "MySnapshot"});
     * ```
     * @param name - The name of the snapshot.
     * @param options - Optional parameters for the request.
     */
    archiveSnapshot(name: string, options?: UpdateSnapshotOptions): Promise<UpdateSnapshotResponse>;
    /**
     * List all snapshots from Azure App Configuration service
     *
     * Example usage:
     * ```ts
     * const result = await client.listSnapshots();
     * ```
     * @param options - Optional parameters for the request.
     */
    listSnapshots(options?: ListSnapshotsOptions): PagedAsyncIterableIterator<ConfigurationSnapshot, ListSnapshotsPage, PageSettings>;
    private sendSnapShotsRequest;
}

/**
 * Provides configuration options for AppConfigurationClient.
 */
export declare interface AppConfigurationClientOptions extends CommonClientOptions {
    /**
     * The API version to use when interacting with the service. The default value is `2023-11-01`.
     * Note that overriding this default value may result in unsupported behavior.
     */
    apiVersion?: string;
}

/**
 * Configuration setting with extra metadata from the server, indicating
 * its etag, whether it is currently readOnly and when it was last modified.
 */
export declare type ConfigurationSetting<T extends string | FeatureFlagValue | SecretReferenceValue = string> = ConfigurationSettingParam<T> & {
    /**
     * Whether or not the setting is read-only
     */
    isReadOnly: boolean;
    /**
     * The date when this setting was last modified
     */
    lastModified?: Date;
};

/**
 * Fields that uniquely identify a configuration setting
 */
export declare interface ConfigurationSettingId {
    /**
     * The etag for this setting
     */
    etag?: string;
    /**
     * The key for this setting.
     * Feature flags must be prefixed with `.appconfig.featureflag/<feature-flag-name>`.
     */
    key: string;
    /**
     * The label for this setting. Leaving this undefined means this
     * setting does not have a label.
     */
    label?: string;
}

/**
 * Necessary fields for updating or creating a new configuration setting
 */
export declare type ConfigurationSettingParam<T extends string | FeatureFlagValue | SecretReferenceValue = string> = ConfigurationSettingId & {
    /**
     * The content type of the setting's value
     */
    contentType?: string;
    /**
     * Tags for this key
     */
    tags?: {
        [propertyName: string]: string;
    };
} & (T extends string ? {
    /**
     * The setting's value
     */
    value?: string;
} : {
    /**
     * The setting's value
     */
    value: T;
});

/**
 * Standard base response for getting, deleting or updating a configuration setting
 */
export declare type ConfigurationSettingResponse<HeadersT> = ConfigurationSetting & HttpResponseField<HeadersT> & Pick<HeadersT, Exclude<keyof HeadersT, "eTag">>;

/** Enables filtering of key-values. Syntax reference: https://aka.ms/azconfig/docs/restapisnapshots */
export declare interface ConfigurationSettingsFilter {
    /** Filters key-values by their key field. */
    keyFilter: string;
    /** Filters key-values by their label field. */
    labelFilter?: string;
    /** Filters key-values by their tags field. */
    tagsFilter?: string[];
}

/** Snapshot details include name, filters, expiresOn, sizeInBytes, status, itemCount, and more */
export declare interface ConfigurationSnapshot {
    /**
     * The name of the snapshot.
     * NOTE: This property will not be serialized. It can only be populated by the server.
     */
    readonly name: string;
    /**
     * The current status of the snapshot.
     * NOTE: This property will not be serialized. It can only be populated by the server.
     */
    readonly status?: ConfigurationSnapshotStatus;
    /** A list of filters used to filter the key-values included in the snapshot. */
    filters: ConfigurationSettingsFilter[];
    /** The composition type describes how the key-values within the snapshot are composed. The 'key' composition type ensures there are no two key-values containing the same key. The 'key_label' composition type ensures there are no two key-values containing the same key and label. */
    compositionType?: SnapshotComposition;
    /**
     * The time that the snapshot was created.
     * NOTE: This property will not be serialized. It can only be populated by the server.
     */
    readonly createdOn?: Date;
    /**
     * The time that the snapshot will expire.
     * NOTE: This property will not be serialized. It can only be populated by the server.
     */
    readonly expiresOn?: Date;
    /** The amount of time, in seconds, that a snapshot will remain in the archived state before expiring. This property is only writable during the creation of a snapshot. If not specified, the default lifetime of key-value revisions will be used. */
    retentionPeriodInSeconds?: number;
    /**
     * The size in bytes of the snapshot.
     * NOTE: This property will not be serialized. It can only be populated by the server.
     */
    readonly sizeInBytes?: number;
    /**
     * The amount of key-values in the snapshot.
     * NOTE: This property will not be serialized. It can only be populated by the server.
     */
    readonly itemCount?: number;
    /** The tags of the snapshot. */
    tags?: {
        [propertyName: string]: string;
    };
    /**
     * A value representing the current state of the snapshot.
     * NOTE: This property will not be serialized. It can only be populated by the server.
     */
    readonly etag?: string;
}

/**
 * Defines values for ConfigurationSnapshotStatus. \
 * {@link KnownConfigurationSnapshotStatus} can be used interchangeably with ConfigurationSnapshotStatus,
 *  this enum contains the known values that the service supports.
 * ### Known values supported by the service
 * **provisioning** \
 * **ready** \
 * **archived** \
 * **failed**
 */
export declare type ConfigurationSnapshotStatus = string;

/**
 * Options used when creating a Snapshot.
 */
export declare interface CreateSnapshotOptions extends OperationOptions {
    /**
     * The amount of time to wait (in milliseconds) between subsequent requests relating to the same operation.
     */
    updateIntervalInMs?: number;
}

/**
 * Response from updating a Snapshot.
 */
export declare interface CreateSnapshotResponse extends SnapshotResponse {
}

/**
 * Options for deleting a ConfigurationSetting.
 */
export declare interface DeleteConfigurationSettingOptions extends HttpOnlyIfUnchangedField, OperationOptions {
}

/**
 * Response from deleting a ConfigurationSetting.
 */
export declare interface DeleteConfigurationSettingResponse extends SyncTokenHeaderField, HttpResponseFields, HttpResponseField<SyncTokenHeaderField> {
}

/**
 * Entity with etag.
 */
export declare interface EtagEntity {
    /**
     * The etag for this entity
     */
    etag?: string;
}

/**
 * The content type for a FeatureFlag
 */
export declare const featureFlagContentType = "application/vnd.microsoft.appconfig.ff+json;charset=utf-8";

/**
 * The prefix for feature flags.
 */
export declare const featureFlagPrefix = ".appconfig.featureflag/";

/**
 * Value of a feature flag
 */
export declare interface FeatureFlagValue {
    /**
     * Id for the feature flag.
     */
    id?: string;
    /**
     * A Feature filter consistently evaluates the state of a feature flag.
     * Our feature management library supports three types of built-in filters: Targeting, TimeWindow, and Percentage.
     * Custom filters can also be created based on different factors, such as device used, browser types, geographic location, etc.
     *
     * [More Info](https://docs.microsoft.com/en-us/azure/azure-app-configuration/howto-feature-filters-aspnet-core)
     */
    conditions: {
        clientFilters: {
            name: string;
            parameters?: Record<string, unknown>;
        }[];
    };
    /**
     * Description of the feature.
     */
    description?: string;
    /**
     * Boolean flag to say if the feature flag is enabled.
     */
    enabled: boolean;
    /**
     * Display name for the feature to use for display rather than the ID.
     */
    displayName?: string;
}

/**
 * Headers from getting a ConfigurationSetting.
 */
export declare interface GetConfigurationHeaders extends SyncTokenHeaderField {
}

/**
 * Options for getting a ConfigurationSetting.
 */
export declare interface GetConfigurationSettingOptions extends OperationOptions, HttpOnlyIfChangedField, OptionalFields {
    /**
     * Requests the server to respond with the state of the resource at the specified time.
     */
    acceptDateTime?: Date;
}

/**
 * Response from retrieving a ConfigurationSetting.
 */
export declare interface GetConfigurationSettingResponse extends ConfigurationSetting, GetConfigurationHeaders, HttpResponseFields, HttpResponseField<GetConfigurationHeaders> {
}

/**
 * Options used when getting a Snapshot.
 */
export declare interface GetSnapshotOptions extends OperationOptions, OptionalSnapshotFields {
}

/**
 * Response from getting a Snapshot.
 */
export declare interface GetSnapshotResponse extends SnapshotResponse {
}

/**
 * Options used to provide if-none-match for an HTTP request
 */
export declare interface HttpOnlyIfChangedField {
    /**
     * Used to perform an operation only if the targeted resource's etag does not match the value
     * provided.
     */
    onlyIfChanged?: boolean;
}

/**
 * Options used to provide if-match for an HTTP request
 */
export declare interface HttpOnlyIfUnchangedField {
    /**
     * Used to perform an operation only if the targeted resource's etag matches the value provided.
     */
    onlyIfUnchanged?: boolean;
}

/**
 * HTTP response related information - headers and raw body.
 */
export declare interface HttpResponseField<HeadersT> {
    /**
     * The underlying HTTP response.
     */
    _response: CompatResponse & {
        /**
         * The parsed HTTP response headers.
         */
        parsedHeaders: HeadersT;
        /**
         * The response body as text (string format)
         */
        bodyAsText: string;
    };
}

/**
 * Fields that are hoisted up  from the _response field of the object
 * Used in cases where individual HTTP response fields are important for
 * the user to use in common-use cases like handling http status codes 204 or 304.
 */
export declare interface HttpResponseFields {
    /**
     * The HTTP status code for the response
     */
    statusCode: number;
}

/**
 * Lets you know if the ConfigurationSetting is a feature flag.
 *
 * [Checks if the content type is featureFlagContentType `"application/vnd.microsoft.appconfig.ff+json;charset=utf-8"`]
 */
export declare function isFeatureFlag(setting: ConfigurationSetting): setting is ConfigurationSetting & Required<Pick<ConfigurationSetting, "value">>;

/**
 * Lets you know if the ConfigurationSetting is a secret reference.
 *
 * [Checks if the content type is secretReferenceContentType `"application/vnd.microsoft.appconfig.keyvaultref+json;charset=utf-8"`]
 */
export declare function isSecretReference(setting: ConfigurationSetting): setting is ConfigurationSetting & Required<Pick<ConfigurationSetting, "value">>;

/** Known values of {@link ConfigurationSnapshotStatus} that the service accepts. */
export declare enum KnownConfigurationSnapshotStatus {
    /** Provisioning */
    Provisioning = "provisioning",
    /** Ready */
    Ready = "ready",
    /** Archived */
    Archived = "archived",
    /** Failed */
    Failed = "failed"
}

/** Known values of {@link SnapshotComposition} that the service accepts. */
export declare enum KnownSnapshotComposition {
    /** Key */
    Key = "key",
    /** KeyLabel */
    KeyLabel = "key_label"
}

/**
 * A page of configuration settings and the corresponding HTTP response
 */
export declare interface ListConfigurationSettingPage extends HttpResponseField<SyncTokenHeaderField>, PageSettings, EtagEntity {
    /**
     * The configuration settings for this page of results.
     */
    items: ConfigurationSetting[];
}

/**
 * Common options for 'list' style APIs in AppConfig used to specify wildcards as well as
 * the accept date time header.
 */
export declare interface ListConfigurationSettingsForSnapshotOptions extends OperationOptions, OptionalFields {
}

/**
 * Options for listConfigurationSettings that allow for filtering based on keys, labels and other fields.
 * Also provides `fields` which allows you to selectively choose which fields are populated in the
 * result.
 */
export declare interface ListConfigurationSettingsOptions extends OperationOptions, ListSettingsOptions {
    /**
     * Etags list for page
     */
    pageEtags?: string[];
}

/**
 * Options for listLabels
 */
export declare interface ListLabelsOptions extends OperationOptions, OptionalLabelsFields {
    /** A filter for the name of the returned labels. */
    nameFilter?: string;
    /**
     * Requests the server to respond with the state of the resource at the specified time.
     */
    acceptDateTime?: Date;
}

/**
 * A page of configuration settings and the corresponding HTTP response
 */
export declare interface ListLabelsPage extends HttpResponseField<SyncTokenHeaderField>, PageSettings, EtagEntity {
    /**
     * The collection of labels
     */
    items: SettingLabel[];
}

/**
 * Options for listRevisions that allow for filtering based on keys, labels and other fields.
 * Also provides `fields` which allows you to selectively choose which fields are populated in the
 * result.
 */
export declare interface ListRevisionsOptions extends OperationOptions, ListSettingsOptions {
}

/**
 * A page of configuration settings and the corresponding HTTP response
 */
export declare interface ListRevisionsPage extends HttpResponseField<SyncTokenHeaderField>, PageSettings {
    /**
     * The configuration settings for this page of results.
     */
    items: ConfigurationSetting[];
}

/**
 * Common options for 'list' style APIs in AppConfig used to specify wildcards as well as
 * the accept date time header.
 */
export declare interface ListSettingsOptions extends OptionalFields {
    /**
     * Requests the server to respond with the state of the resource at the specified time.
     */
    acceptDateTime?: Date;
    /**
     * Filters for keys. There are two types of matching:
     *
     * 1. Exact matching. Up to 5 key names are allowed, separated by commas (',')
     * 2. Wildcard matching. A single wildcard expression can be specified.
     *
     *    | Value        | Matches                               |
     *    |--------------|---------------------------------------|
     *    | omitted or * | Matches any key                       |
     *    | abc          | Matches a key named abc               |
     *    | abc*         | Matches key names that start with abc |
     *
     * These characters are reserved and must be prefixed with backslash in order
     * to be specified: * or \\ or ,
     */
    keyFilter?: string;
    /**
     * Filters for labels. There are two types of matching:
     *
     * 1. Exact matching. Up to 5 labels are allowed, separated by commas (',')
     * 2. Wildcard matching. A single wildcard expression can be specified.
     *
     *    | Value        | Matches                                              |
     *    |--------------|------------------------------------------------------|
     *    | omitted or * | Matches any key                                      |
     *    | \0           | Matches any key without a label (URL encoded as %00) |
     *    | prod         | Matches a key with label named prod                  |
     *    | prod*        | Matches key with label names that start with prod    |
     * These characters are reserved and must be prefixed with backslash in order
     * to be specified: * or \\ or ,
     *
     * Reference: https://learn.microsoft.com/azure/azure-app-configuration/rest-api-key-value
     */
    labelFilter?: string;
    /** A filter used to query by tags. Syntax reference: https://aka.ms/azconfig/docs/keyvaluefiltering */
    tagsFilter?: string[];
}

/**
 * Common options for 'list' style APIs in AppConfig used to specify wildcards as well as
 * the accept date time header.
 */
export declare interface ListSnapshots extends OptionalSnapshotFields {
    /** A filter for the name of the returned snapshots. */
    nameFilter?: string;
    /** Used to filter returned snapshots by their status property. */
    statusFilter?: ConfigurationSnapshotStatus[];
}

/**
 * Options for listConfigurationSettings that allow for filtering based on keys, labels and other fields.
 * Also provides `fields` which allows you to selectively choose which fields are populated in the
 * result.
 */
export declare interface ListSnapshotsOptions extends OperationOptions, ListSnapshots, OptionalSnapshotFields {
}

/**
 * A page of configuration settings and the corresponding HTTP response
 */
export declare interface ListSnapshotsPage extends SyncTokenHeaderField, PageSettings {
    /**
     * The configuration settings for this page of results.
     */
    items: ConfigurationSnapshot[];
}

/**
 * Used when the API supports selectively returning fields.
 */
export declare interface OptionalFields {
    /**
     * Which fields to return for each ConfigurationSetting
     */
    fields?: (keyof ConfigurationSetting)[];
}

/**
 * Used when the API supports selectively returning labels fields.
 */
export declare interface OptionalLabelsFields {
    /**
     * Which fields to return for each ConfigurationSetting
     */
    fields?: (keyof SettingLabel)[];
}

/**
 * Used when the API supports selectively returning fields.
 */
export declare interface OptionalSnapshotFields {
    /**
     * Which fields to return for each ConfigurationSetting
     */
    fields?: (keyof ConfigurationSnapshot)[];
}

/**
 * An interface that tracks the settings for paged iteration
 */
export declare interface PageSettings {
    /**
     * The token that keeps track of where to continue the iterator
     */
    continuationToken?: string;
}

/**
 * Takes the ConfigurationSetting as input and returns the ConfigurationSetting<FeatureFlagValue> by parsing the value string.
 */
export declare function parseFeatureFlag(setting: ConfigurationSetting): ConfigurationSetting<FeatureFlagValue>;

/**
 * Takes the ConfigurationSetting as input and returns the ConfigurationSetting<SecretReferenceValue> by parsing the value string.
 */
export declare function parseSecretReference(setting: ConfigurationSetting): ConfigurationSetting<SecretReferenceValue>;

/**
 * Options that control how to retry failed requests.
 */
export declare interface RetryOptions {
    /**
     * The maximum number of retry attempts.  Defaults to 3.
     */
    maxRetries?: number;
    /**
     * The maximum delay in milliseconds allowed before retrying an operation.
     */
    maxRetryDelayInMs?: number;
}

/**
 * content-type for the secret reference.
 */
export declare const secretReferenceContentType = "application/vnd.microsoft.appconfig.keyvaultref+json;charset=utf-8";

/**
 * Necessary fields for updating or creating a new secret reference.
 */
export declare interface SecretReferenceValue {
    /**
     * Id for the secret reference.
     */
    secretId: string;
}

/**
 * Options used when saving a ConfigurationSetting.
 */
export declare interface SetConfigurationSettingOptions extends HttpOnlyIfUnchangedField, OperationOptions {
}

/**
 * Parameters for creating or updating a new configuration setting
 */
export declare type SetConfigurationSettingParam<T extends string | FeatureFlagValue | SecretReferenceValue = string> = ConfigurationSettingParam<T>;

/**
 * Response from setting a ConfigurationSetting.
 */
export declare interface SetConfigurationSettingResponse extends ConfigurationSetting, SyncTokenHeaderField, HttpResponseField<SyncTokenHeaderField> {
}

/**
 * Options for setReadOnly
 */
export declare interface SetReadOnlyOptions extends HttpOnlyIfUnchangedField, OperationOptions {
}

/**
 * Response when setting a value to read-only.
 */
export declare interface SetReadOnlyResponse extends ConfigurationSetting, SyncTokenHeaderField, HttpResponseField<SyncTokenHeaderField> {
}

/** Label details, with name property that can only be populated by the server */
export declare interface SettingLabel {
    /**
     * The name of the label.
     * NOTE: This property will not be serialized. It can only be populated by the server.
     */
    readonly name?: string;
}

/**
 * Defines values for SnapshotComposition. \
 * {@link KnownSnapshotComposition} can be used interchangeably with SnapshotComposition,
 *  this enum contains the known values that the service supports.
 * ### Known values supported by the service
 * **key** \
 * **key_label**
 */
export declare type SnapshotComposition = string;

/**
 * Fields that uniquely identify a snapshot
 */
export declare interface SnapshotInfo {
    /** The name for this snapshot */
    name: string;
    /** A list of filters used to filter the key-values included in the snapshot. */
    filters: ConfigurationSettingsFilter[];
    /** The composition type describes how the key-values within the snapshot are composed. The 'all' composition type includes all key-values. The 'group_by_key' composition type ensures there are no two key-values containing the same key. */
    compositionType?: SnapshotComposition;
    /** The amount of time, in seconds, that a snapshot will remain in the archived state before expiring. This property is only writable during the creation of a snapshot. If not specified, the default lifetime of key-value revisions will be used. */
    retentionPeriodInSeconds?: number;
    /** The tags of the snapshot. */
    tags?: {
        [propertyName: string]: string;
    };
}

/**
 * Response from adding a Snapshot.
 */
export declare interface SnapshotResponse extends ConfigurationSnapshot, SyncTokenHeaderField {
}

/**
 * Sync token header field
 */
export declare interface SyncTokenHeaderField {
    /**
     * Enables real-time consistency between requests by providing the returned value in the next
     * request made to the server.
     */
    syncToken?: string;
}

/**
 * Options used when updating a Snapshot.
 */
export declare interface UpdateSnapshotOptions extends OperationOptions {
    /**
     * The etag for this snapshot
     */
    etag?: string;
}

/**
 * Response from updating a Snapshot.
 */
export declare interface UpdateSnapshotResponse extends SnapshotResponse {
}

export { }