h*.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ 4.3.0 Safe-Inferred"%&1<>    Safe-Inferred"%&1<>launchdarkly-server-sdk(The status of the client initialization.launchdarkly-server-sdk;The client has not yet finished connecting to LaunchDarkly.launchdarkly-server-sdk?The client attempted to connect to LaunchDarkly and was denied.launchdarkly-server-sdk5The client has successfuly connected to LaunchDarkly.launchdarkly-server-sdkThe client is being terminated  Safe-Inferred"%&1<>  Safe-Inferred"%&1<>G  Safe-Inferred"#%&1<>mlaunchdarkly-server-sdkDefines the possible values of the errorKind property of EvaluationReason.launchdarkly-server-sdkIndicates that there was an internal inconsistency in the flag data, e.g. a rule specified a nonexistent variation.launchdarkly-server-sdkIndicates that the caller provided a flag key that did not match any known flag.launchdarkly-server-sdkIndicates that the result value was not of the requested type, e.g. you called boolVariationDetail but the value was an integer.launchdarkly-server-sdkIndicates that the caller tried to evaluate a flag before the client had successfully initialized.launchdarkly-server-sdkIndicates that the caller tried to evaluate a flag with an invalid contextlaunchdarkly-server-sdkIndicates that some error was returned by the external feature store. launchdarkly-server-sdkDefines the possible values of the Kind property of EvaluationReason.!launchdarkly-server-sdkIndicates that the flag was off and therefore returned its configured off value."launchdarkly-server-sdkindicates that the context key was specifically targeted for this flag.'launchdarkly-server-sdk;The index of the rule that was matched (0 being the first).(launchdarkly-server-sdk3The unique identifier of the rule that was matched.)launchdarkly-server-sdkWhether the evaluation was part of an experiment. Is true if the evaluation resulted in an experiment rollout *and* served one of the variations in the experiment. Otherwise false.*launchdarkly-server-sdk-The flag key of the prerequisite that failed.+launchdarkly-server-sdkDescribes the type of error.,launchdarkly-server-sdkCombines the result of a flag evaluation with an explanation of how it was calculated..launchdarkly-server-sdkThe result of the flag evaluation. This will be either one of the flag's variations or the default value passed by the application./launchdarkly-server-sdkThe index of the returned value within the flag's list of variations, e.g. 0 for the first variation - or Nothing if the default value was returned.0launchdarkly-server-sdkDescribes the main factor that influenced the flag evaluation value. +*)('&%$#"!,/.0- Safe-Inferred"%&1<> Safe-Inferred"%&'(1<>1launchdarkly-server-sdk#data record for the Reference type.2launchdarkly-server-sdkCreates a Reference from a string. For the supported syntax and examples, see comments on the LaunchDarkly.Server.Reference module.This function always returns a Reference that preserves the original string, even if validation fails, so that accessing 7 (or serializing the Reference to JSON) will produce the original string. If validation fails, 5 will return an error and any SDK method that takes this Reference as a parameter will consider it invalid.3launchdarkly-server-sdkmakeLiteral is similar to 2 except that it always interprets the string as a literal attribute name, never as a slash-delimited path expression. There is no escaping or unescaping, even if the name contains literal  or  characters. Since an attribute name can contain any characters, this method always returns a valid Reference unless the name is empty. For example: makeLiteral "name" is exactly equivalent to makeReference "name". makeLiteral "a/b" is exactly equivalent to makeReference "a/b" (since the syntax used by 2 treats the whole string as a literal as long as it does not start with a slash), or to makeReference "/a~1b".4launchdarkly-server-sdk4Returns True for a valid Reference; False otherwise.A Reference is invalid if the input string is empty, or starts with a slash but is not a valid slash-delimited path, or starts with a slash and contains an invalid escape sequence.Otherwise, the Reference is valid, but that does not guarantee that such an attribute exists in any given Context. For instance, makeReference "name" is a valid Reference, but a specific Context might or might not have a name.See comments on the LaunchDarkly.Server.Reference< module for more details of the attribute reference syntax.5launchdarkly-server-sdkReturns an empty string for a valid Reference, or a Text error description for an invalid Reference.See comments on the LaunchDarkly.Server.Reference< module for more details of the attribute reference syntax.6launchdarkly-server-sdk7Retrieves path components from the attribute reference.-Invalid references will return an empty list. makeReference "" & getComponents -- returns [] makeReference "a" & getComponents -- returns ["a"] makeReference "/a/b" & getComponents -- returns ["a", "b"]7launchdarkly-server-sdkReturns the attribute reference as a string, in the same format provided to 2."If the Reference was created with 2, this value is identical to the original string. If it was created with 3, the value may be different due to unescaping (for instance, an attribute whose name is "/a" would be represented as "~1a").12345671234567 Safe-Inferred"%&1<> Safe-Inferred"%&'1<>Hk<launchdarkly-server-sdk1A builder for feature flag rules to be used with D.In the LaunchDarkly model, a flag can have any number of rules, and a rule can have any number of clauses. A clause is an individual test such as "name is 'X'". A rule matches a context if all of the rule's clauses match the context.To start defining a rule, use one of the matching functions such as L or N-. This defines the first clause for the rule.Optionally, you may add more clauses with the rule builder functions such as P and R.Finally, call C to finish defining the rule.=launchdarkly-server-sdkSpecifies the fallthrough variation. The fallthrough is the value that is returned if targeting is on and the context was not matched by a more specific target or rule.If the flag was previously configured with other variations and the variation specified is a boolean, this also changes it to a boolean flag.>launchdarkly-server-sdkSpecifies the off variation for a flag. This is the variation that is returned whenever targeting is off.If the flag was previously configured with other variations and the variation specified is a boolean, this also changes it to a boolean flag.?launchdarkly-server-sdkSets the flag to always return the specified variation for all contexts.The variation is specified, Targeting is switched on, and any existing targets or rules are removed. The fallthrough variation is set to the specified value. The off variation is left unchanged.If the flag was previously configured with other variations and the variation specified is a boolean, this also changes it to a boolean flag.@launchdarkly-server-sdkSets the flag to always return the specified variation for all users.The variation is specified, Targeting is switched on, and any existing targets or rules are removed. The fallthrough variation is set to the specified value. The off variation is left unchanged.If the flag was previously configured with other variations and the variation specified is a boolean, this also changes it to a boolean flag.Alaunchdarkly-server-sdkSets the flag to return the specified variation for a specific context kind and key when targeting is on.=This has no effect when targeting is turned off for the flag.If the flag was previously configured with other variations and the variation specified is a boolean, this also changes it to a boolean flag.Blaunchdarkly-server-sdkSets the flag to return the specified variation for a specific user key when targeting is on.=This has no effect when targeting is turned off for the flag.If the flag was previously configured with other variations and the variation specified is a boolean, this also changes it to a boolean flag.Claunchdarkly-server-sdkFinishes defining the rule, specifying the result as either a boolean or a variation index.If the flag was previously configured with other variations and the variation specified is a boolean, this also changes it to a boolean flag.Dlaunchdarkly-server-sdk;A builder for feature flag configurations to be used with )LaunchDarkly.Server.Integrations.TestData.see  and Flaunchdarkly-server-sdkA shortcut for setting the flag to use the standard boolean configuration.4This is the default for all new flags created with &. The flag will have two variations, True and False! (in that order); it will return False! whenever targeting is off, and True> when targeting is on if no other settings specify otherwise.Glaunchdarkly-server-sdk-Sets targeting to be on or off for this flag.The effect of this depends on the rest of the flag configuration, just as it does on the real LaunchDarkly dashboard. In the default configuration that you get from calling , with a new flag key, the flag will return False! whenever targeting is off, and True when targeting is on.launchdarkly-server-sdkRemoves any existing rules from the flag. This undoes the effect of methods like L or Nlaunchdarkly-server-sdkRemoves any existing targets from the flag. This undoes the effect of methods like AHlaunchdarkly-server-sdkSets the flag to always return the specified variation value for all contexts.-The value may be of any type that implements . This method changes the flag to have only a single variation, which is this value, and to return the same variation regardless of whether targeting is on or off. Any existing targets or rules are removed.Ilaunchdarkly-server-sdkSets the flag to always return the specified variation value for all users.This function is an alias to H.-The value may be of any type that implements . This method changes the flag to have only a single variation, which is this value, and to return the same variation regardless of whether targeting is on or off. Any existing targets or rules are removed.Jlaunchdarkly-server-sdk4Changes the allowable variation values for the flag.1The value may be of any JSON type, as defined by . For instance, a boolean flag normally has [toJSON True, toJSON False]; a string-valued flag might have [toJSON "red", toJSON "green"]; etc.Klaunchdarkly-server-sdklaunchdarkly-server-sdkTrue or False or the desired fallthrough variation index: 0 for the first, 1 for the second, etc.?launchdarkly-server-sdkTrue or False or the desired fallthrough variation index: 0 for the first, 1 for the second, etc.@launchdarkly-server-sdkTrue or False or the desired fallthrough variation index: 0 for the first, 1 for the second, etc.Alaunchdarkly-server-sdk!The context kind to match againstlaunchdarkly-server-sdka key to targetlaunchdarkly-server-sdkTrue or False or the desired fallthrough variation index: 0 for the first, 1 for the second, etc.Blaunchdarkly-server-sdka user key to targetlaunchdarkly-server-sdkTrue or False or the desired fallthrough variation index: 0 for the first, 1 for the second, etc.Claunchdarkly-server-sdkTrue or False or the desired fallthrough variation index: 0 for the first, 1 for the second, etc.Glaunchdarkly-server-sdkisOn True if targeting should be onJlaunchdarkly-server-sdkthe desired variationsKlaunchdarkly-server-sdkthe context kind to match againlaunchdarkly-server-sdk&the context attribute to match againstlaunchdarkly-server-sdkvalues to compare tolaunchdarkly-server-sdkcall C, to finish the rule, or add more tests with P or RLlaunchdarkly-server-sdk&the context attribute to match againstlaunchdarkly-server-sdkvalues to compare tolaunchdarkly-server-sdkcall C, to finish the rule, or add more tests with P or RMlaunchdarkly-server-sdkcontext kind to match againlaunchdarkly-server-sdkattribute to match againstlaunchdarkly-server-sdkvalues to compare tolaunchdarkly-server-sdkcall C, to finish the rule, or add more tests with P or RNlaunchdarkly-server-sdkattribute to match againstlaunchdarkly-server-sdkvalues to compare tolaunchdarkly-server-sdkcall C, to finish the rule, or add more tests with P or ROlaunchdarkly-server-sdkthe context kind to match againlaunchdarkly-server-sdk&the context attribute to match againstlaunchdarkly-server-sdkvalues to compare toPlaunchdarkly-server-sdk&the context attribute to match againstlaunchdarkly-server-sdkvalues to compare toQlaunchdarkly-server-sdk!the context kind to match againstlaunchdarkly-server-sdk&the context attribute to match againstlaunchdarkly-server-sdkvalues to compare toRlaunchdarkly-server-sdk&the context attribute to match againstlaunchdarkly-server-sdkvalues to compare to"DEFG=>?@ABCHIJLKNMPSlaunchdarkly-server-sdkA record representing an object that can be persisted in an external store.Ulaunchdarkly-server-sdkA serialized item. If the item is deleted or does not exist this should be .Vlaunchdarkly-server-sdkThe version of a given item. If the item does not exist this should be zero.Wlaunchdarkly-server-sdk=True if this is a placeholder (tombstone) for a deleted item.Xlaunchdarkly-server-sdkThe interface implemented by external stores for use by the SDK.Zlaunchdarkly-server-sdk=A map of all features in a given namespace including deleted.[launchdarkly-server-sdk)Return the value of a key in a namespace.\launchdarkly-server-sdkUpsert a given feature. Versions should be compared before upsert. The result should indicate if the feature was replaced or not.]launchdarkly-server-sdkChecks if the external store has been initialized, which may have been done by another instance of the SDK.^launchdarkly-server-sdkA map of namespaces, and items in namespaces. The entire store state should be replaced with these values._launchdarkly-server-sdk3Represents a namespace such as features or segments`launchdarkly-server-sdk'Represents the key for a given feature.alaunchdarkly-server-sdkThe result type for every X function. Instead of throwing an exception, any store related error should return :. Exceptions unrelated to the store should not be caught.blaunchdarkly-server-sdk Generate a  representation of the S.If the S has either a  value, or is marked as deleted, the ByteString representation will be a tombstone marker containing the version and deletion status.8Otherwise, the internal item representation is returned.claunchdarkly-server-sdk0Partially decode the provided ByteString into a  struct.This is useful for persistent stores who need to perform version comparsions before persisting data.7aXYZ[\]^STVWU`_bc Safe-Inferred"%&1<>Qea`_XYZ[\]^STVWUbca`_XYZ[\]^STVWUbc Safe-Inferred"%&1<>Q Safe-Inferred"%&1<>Xflaunchdarkly-server-sdk/Creates a new instance of the test data source.glaunchdarkly-server-sdkCreates or copies a D( for building a test flag configuration.2If this flag key has already been defined in this d instance, then the builder starts with the same configuration that was last provided for this flag.Otherwise, it starts with a new default configuration in which the flag has True and False variations, is True1 for all users when targeting is turned on and False otherwise, and currently has targeting turned on. You can change any of those properties, and provide more complex behavior, using the D methods.Once you have set the desired configuration, pass the builder to h.see hhlaunchdarkly-server-sdk?@ABCHIJLKNME?@HIABJLKNMEeilaunchdarkly-server-sdk Creates a DataSourceFactory- which uses the configured file data sources.This allows you to use local files as a source of feature flag state, instead of using an actual LaunchDarkly connection.2To use the file dataSource you can add it to the  using  let config = configSetDataSourceFactory (FileData.dataSourceFactory [".testDataflags.json"]) $ makeConfig "sdk-key" client <- makeClient config This will cause the client not to connect to LaunchDarkly to get feature flags. The client may still make network connections to send analytics events, unless you have disabled this with  to False. IMPORTANT: Do not set  to True; doing so would not just put the SDK "offline" with regard to LaunchDarkly, but will completely turn off all flag data sources to the SDK /including the file data source/.Flag data files can be either JSON or YAML. They contain an object with three possible properties: flagsFeature flag definitions. flagValues3Simplified feature flags that contain only a value.segmentsContext segment definitions.The format of the data in flags and segments is defined by the LaunchDarkly application and is subject to change. Rather than trying to construct these objects yourself, it is simpler to request existing flags directly from the LaunchDarkly server in JSON format, and use this output as the starting point for your file. In Linux you would do this: (curl -H "Authorization: {your sdk key}"  +https://sdk.launchdarkly.com/sdk/latest-all The output will look something like this (but with many more properties): { "flags": { "flag-key-1": { "key": "flag-key-1", "on": true, "variations": [ "a", "b" ] }, "flag-key-2": { "key": "flag-key-2", "on": true, "variations": [ "c", "d" ] } }, "segments": { "segment-key-1": { "key": "segment-key-1", "includes": [ "user-key-1" ] } } } Data in this format allows the SDK to exactly duplicate all the kinds of flag behavior supported by LaunchDarkly. However, in many cases you will not need this complexity, but will just want to set specific flag keys to specific values. For that, you can use a much simpler format: { "flagValues": { "my-string-flag-key": "value-1", "my-boolean-flag-key": true, "my-integer-flag-key": 3 } }  Or, in YAML: flagValues: my-string-flag-key: "value-1" my-boolean-flag-key: true $It is also possible to specify both flags and  flagValues, if you want some flags to have simple values and others to have complex behavior. However, it is an error to use the same flag key or segment key more than once, either in a single file or across multiple files.If the data source encounters any error in any file(malformed content, a missing file) it will not load flags from that file. If the data source encounters a duplicate key it will ignore that duplicate entry.ii Safe-Inferred"%&1<>i2wlaunchdarkly-server-sdkz~ {launchdarkly-server-sdk data record for the Context type|launchdarkly-server-sdk4Create a single kind context from the provided hash.;The provided hash must match the format as outlined in the  6https://docs.launchdarkly.com/sdk/features/user-configSDK documentation.}launchdarkly-server-sdk?Create a multi-kind context from the list of Contexts provided.A multi-kind context is comprised of two or more single kind contexts. You cannot include a multi-kind context instead another multi-kind context.Additionally, the kind of each single-kind context must be unique. For instance, you cannot create a multi-kind context that includes two user kind contexts.If you attempt to create a multi-kind context from one single-kind context, this method will return the single-kind context instead of a new multi-kind context wrapping that one single-kind.~launchdarkly-server-sdk2Sets the name attribute for a single-kind context.Calling this method on an invalid or multi-kind context is a no-op.launchdarkly-server-sdk7Sets the anonymous attribute for a single-kind context.Calling this method on an invalid or multi-kind context is a no-op.launchdarkly-server-sdk0Sets the value of any attribute for the context.This includes only attributes that are addressable in evaluations -- not metadata such as private attributes. For example, if the attribute name is "privateAttributes", you will be setting an attribute with that name which you can use in evaluations or to record data for your own purposes, but it will be unrelated to .If attribute name is "privateAttributeNames", it is ignored and no attribute is set.This method uses the Value type to represent a value of any JSON type: null, boolean, number, string, array, or object. For all attribute names that do not have special meaning to LaunchDarkly, you may use any of those types. Values of different JSON types are always treated as different values: for instance, null, false, and the empty string "" are not the same, and the number 1 is not the same as the string "1".The following attribute names have special restrictions on their value types, and any value of an unsupported type will be ignored (leaving the attribute unchanged):"name": Must be a string."anonymous": Must be a boolean.The attribute name "_meta" is not allowed, because it has special meaning in the JSON schema for contexts; any attempt to set an attribute with this name has no effect.The attribute names "kind" and "key" are not allowed. They must be provided during the initial context creation. See |.Values that are JSON arrays or objects have special behavior when referenced in flag/segment rules.For attributes that aren't subject to the special restrictions mentioned above, a value of Null is equivalent to removing any current non-default value of the attribute. Null is not a valid attribute value in the LaunchDarkly model; any expressions in feature flags that reference an attribute with a null value will behave as if the attribute did not exist.Calling this method on an invalid or multi-kind context is a no-op.launchdarkly-server-sdk6Sets the private attributes for a single-kind context.Calling this method on an invalid or multi-kind context is a no-op.launchdarkly-server-sdkInternally used only.If the config has omitAnonymousContexts set to True, this method will return a new context with all anonymous contexts removed. If the config does not have omitAnonymousContexts set to True, this method will return the context as is.launchdarkly-server-sdkInternally used only.For a multi-kind context:A multi-kind context is made up of two or more single-kind contexts. This method will first discard any single-kind contexts which are anonymous. It will then create a new multi-kind context from the remaining single-kind contexts. This may result in an invalid context (e.g. all single-kind contexts are anonymous).For a single-kind context:If the context is not anonymous, this method will return the current context as is and unmodified.If the context is anonymous, this method will return an invalid context. {|}~ Safe-Inferred"%&'(-1<>launchdarkly-server-sdk,Determines if the provided context is valid.launchdarkly-server-sdk?Returns the error associated with the context if it is invalid.launchdarkly-server-sdkReturns the single-kind Context corresponding to one of the kinds in this context.If this method is called on a single-kind Context and the requested kind matches the context's kind, then that context is returned.If the method is called on a multi-context, the provided kind must match the context kind of one of the individual contexts.(If there is no context corresponding to , the method returns Nothing.launchdarkly-server-sdkLooks up the value of any attribute of the Context by name. This includes only attributes that are addressable in evaluations-- not metadata such as private attributes.For a single-kind context, the attribute name can be any custom attribute. It can also be one of the built-in ones like "kind", "key", or "name".For a multi-kind context, the only supported attribute name is "kind". Use  to inspect a Context for a particular kind and then get its attributes.This method does not support complex expressions for getting individual values out of JSON objects or arrays, such as "addressstreet". Use  for that purpose.If the value is found, the return value is the attribute value; otherwise, it is Null.launchdarkly-server-sdkLooks up the value of any attribute of the Context, or a value contained within an attribute, based on a 1 instance. This includes only attributes that are addressable in evaluations-- not metadata such as private attributes.This implements the same behavior that the SDK uses to resolve attribute references during a flag evaluation. In a single-kind context, the 1 can represent a simple attribute name-- either a built-in one like "name" or "key", or a custom attribute -- or, it can be a slash-delimited path using a JSON-Pointer-like syntax. See 1 for more details.For a multi-kind context, the only supported attribute name is "kind". Use  to inspect a Context for a particular kind and then get its attributes.If the value is found, the return value is the attribute value; otherwise, it is Null. {|}~ {|}~ Safe-Inferred"%&1<> Safe-Inferred"%&1<>7launchdarkly-server-sdk4Create a default configuration from a given SDK key.launchdarkly-server-sdk7Set the SDK key used to authenticate with LaunchDarkly.launchdarkly-server-sdkThe base URI of the main LaunchDarkly service. This should not normally be changed except for testing.launchdarkly-server-sdkThe base URI of the LaunchDarkly streaming service. This should not normally be changed except for testing.launchdarkly-server-sdkThe base URI of the LaunchDarkly service that accepts analytics events. This should not normally be changed except for testing.launchdarkly-server-sdk7Configures a handle to an external store such as Redis.launchdarkly-server-sdkWhen a store backend is configured, control how long values should be cached in memory before going back to the backend.launchdarkly-server-sdkSets whether streaming mode should be enabled. By default, streaming is enabled. It should only be disabled on the advice of LaunchDarkly support.launchdarkly-server-sdkThe initial delay in milliseconds before reconnecting after an error in the SSE client. Defaults to 1 second.This only applies to the streaming connection. Providing a non-positive integer is a no-op.launchdarkly-server-sdkSets whether or not all context attributes (other than the key) should be hidden from LaunchDarkly. If this is true, all context attribute values will be private, not just the attributes specified in PrivateAttributeNames.launchdarkly-server-sdkMarks a set of context attribute names private. Any contexts sent to LaunchDarkly with this configuration active will have attributes with these names removed.launchdarkly-server-sdkThe time between flushes of the event buffer. Decreasing the flush interval means that the event buffer is less likely to reach capacity.launchdarkly-server-sdk2The polling interval (when streaming is disabled).launchdarkly-server-sdkThe number of context keys that the event processor can remember at any one time, so that duplicate context details will not be sent in analytics events.launchdarkly-server-sdk9Deprecated historically named function which proxies to .launchdarkly-server-sdkThe capacity of the events buffer. The client buffers up to this many events in memory before flushing. If the capacity is exceeded before the buffer is flushed, events will be discarded.launchdarkly-server-sdk(Set the logger to be used by the client.launchdarkly-server-sdkSets whether to send analytics events back to LaunchDarkly. By default, the client will send events. This differs from Offline in that it only affects sending events, not streaming or polling for events from the server.launchdarkly-server-sdkSets whether this client is offline. An offline client will not make any network connections to LaunchDarkly, and will return default values for all feature flags.launchdarkly-server-sdkSets how long an the HTTP client should wait before a response is returned.launchdarkly-server-sdkSets whether this client should use the LaunchDarkly Relay Proxy in daemon mode. In this mode, the client does not subscribe to the streaming or polling API, but reads data only from the feature store. See: .https://docs.launchdarkly.com/home/relay-proxylaunchdarkly-server-sdkSets a data source to use instead of the default network based data source see )LaunchDarkly.Server.Integrations.FileDatalaunchdarkly-server-sdk Sets the 6 to use with the client. If not set explicitly a new * will be created when creating the client.launchdarkly-server-sdklaunchdarkly-server-sdkClient is the LaunchDarkly client. Client instances are thread-safe. Applications should instantiate a single instance for the lifetime of their application.launchdarkly-server-sdk$The version string for this library. Safe-Inferred"%&1<>c   Safe-Inferred"%&'1<>! Safe-Inferred"%&1<>" Safe-Inferred"%&1<>r# Safe-Inferred"%&1<>launchdarkly-server-sdk'Returns the first element of a 3-tuple.launchdarkly-server-sdk(Returns the second element of a 3-tuple.launchdarkly-server-sdk'Returns the third element of a 3-tuple.$ Safe-Inferred"%&'(1<>( Safe-Inferred"%&1<>Wlaunchdarkly-server-sdkAllFlagsState captures the state of all feature flag keys as evaluated for a specific context. This includes their values, as well as other metadata.launchdarkly-server-sdk1Create a new instance of the LaunchDarkly client.launchdarkly-server-sdk.Return the initialization status of the Clientlaunchdarkly-server-sdkReturns an object that encapsulates the state of all feature flags for a given context. This includes the flag values, and also metadata that can be used on the front end.The most common use case for this method is to bootstrap a set of client-side feature flags from a back-end service.The first parameter will limit to only flags that are marked for use with the client-side SDK (by default, all flags are included).The second parameter will include evaluation reasons in the state.The third parameter will omit any metadata that is normally only used for event generation, such as flag versions and evaluation reasons, unless the flag has event tracking or debugging turned on0For more information, see the Reference Guide: https://docs.launchdarkly.com/sdk/features/secure-mode#haskell.launchdarkly-server-sdkFlush tells the client that all pending analytics events (if any) should be delivered as soon as possible. Flushing is asynchronous, so this method will return before it is complete.launchdarkly-server-sdkClose shuts down the LaunchDarkly client. After calling this, the LaunchDarkly client should no longer be used. The method will block until all pending analytics events have been sent.launchdarkly-server-sdkEvaluate a Boolean typed flag.launchdarkly-server-sdk9Evaluate a Boolean typed flag, and return an explanation.launchdarkly-server-sdkEvaluate a String typed flag.launchdarkly-server-sdk8Evaluate a String typed flag, and return an explanation.launchdarkly-server-sdk6Evaluate a Number typed flag, and truncate the result.launchdarkly-server-sdkEvaluate a Number typed flag, truncate the result, and return an explanation.launchdarkly-server-sdkEvaluate a Number typed flag.launchdarkly-server-sdk8Evaluate a Number typed flag, and return an explanation.launchdarkly-server-sdkEvaluate a JSON typed flag.launchdarkly-server-sdk6Evaluate a JSON typed flag, and return an explanation.2,-0./ !"#$%&'()*+2,-0./ !"#$%&'()*+ Safe-Inferred"%&1<>6,-0./ !"#$%&'()*+xwyz{|}~% Safe-Inferred"%&1<>&'()*+,-./0123456789 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R R S T UVWXYZ[\]^_`abcdefghijklmnopqrstuvwxxyz{||}~YZ            i !"###$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%4launchdarkly-server-sdk-4.3.0-AeoHhwivWjRDvA2ye73jR4LaunchDarkly.AesonCompatLaunchDarkly.Server.ClientLaunchDarkly.Server.Reference)LaunchDarkly.Server.Integrations.TestDataLaunchDarkly.Server.Store)LaunchDarkly.Server.Integrations.FileDataLaunchDarkly.Server.ConfigLaunchDarkly.Server.Contextlaunchdarkly-server-sdk!LaunchDarkly.Server.Client.Status,LaunchDarkly.Server.Config.HttpConfiguration(LaunchDarkly.Server.Config.ClientContextLaunchDarkly.Server.DetailsLaunchDarkly.Server.OperatorsLaunchDarkly.Server.Features5LaunchDarkly.Server.Integrations.TestData.FlagBuilderflagupdate"LaunchDarkly.Server.Store.Internal'LaunchDarkly.Server.DataSource.InternalClientLaunchDarkly.ServerConfigconfigSetDataSourceFactoryconfigSetSendEventsconfigSetOffline#LaunchDarkly.Server.Config.Internal$LaunchDarkly.Server.Context.InternalLaunchDarkly.Server.Events#LaunchDarkly.Server.Client.Internal"LaunchDarkly.Server.Network.Common%LaunchDarkly.Server.Network.Streaming#LaunchDarkly.Server.Network.Polling$LaunchDarkly.Server.Network.EventingLaunchDarkly.Server.UtilLaunchDarkly.Server.EvaluatePaths_launchdarkly_server_sdkKeyMapnull emptyObject singletonfromListtoList deleteKey lookupKey objectKeys objectValues keyToText insertKey filterKeys filterObject adjustKey mapValues mapWithKeymapMaybeValues keyMapUnion foldrWithKeyStatus Uninitialized Unauthorized Initialized ShuttingDown EvalErrorKindEvalErrorKindMalformedFlagEvalErrorFlagNotFoundEvalErrorWrongTypeEvalErrorClientNotReadyEvalErrorInvalidContextEvalErrorExternalStoreEvaluationReasonEvaluationReasonOffEvaluationReasonTargetMatchEvaluationReasonRuleMatch"EvaluationReasonPrerequisiteFailedEvaluationReasonFallthroughEvaluationReasonError"$sel:ruleIndex:EvaluationReasonOff$sel:ruleId:EvaluationReasonOff%$sel:inExperiment:EvaluationReasonOff($sel:prerequisiteKey:EvaluationReasonOff"$sel:errorKind:EvaluationReasonOffEvaluationDetail$sel:value:EvaluationDetail$$sel:variationIndex:EvaluationDetail$sel:reason:EvaluationDetail Reference makeReference makeLiteralisValidgetError getComponents getRawPath$fToJSONReference$fOrdReference$fShowReference $fEqReferenceFlagRuleBuilderfallthroughVariation offVariationvariationForAllvariationForAllUsersvariationForKeyvariationForUser thenReturn FlagBuilderVariationIndex booleanFlagon valueForAllvalueForAllUsers variationsifMatchContextifMatchifNotMatchContext ifNotMatchandMatchContextandMatchandNotMatchContext andNotMatchSerializedItemDescriptor"$sel:item:SerializedItemDescriptor%$sel:version:SerializedItemDescriptor%$sel:deleted:SerializedItemDescriptorPersistentDataStore7$sel:persistentDataStoreAllFeatures:PersistentDataStore6$sel:persistentDataStoreGetFeature:PersistentDataStore9$sel:persistentDataStoreUpsertFeature:PersistentDataStore9$sel:persistentDataStoreIsInitialized:PersistentDataStore6$sel:persistentDataStoreInitialize:PersistentDataStoreFeatureNamespace FeatureKey StoreResultserializeWithPlaceholderbyteStringToVersionedDataTestDatadataSourceFactory newTestData$fMonoidFileBody$fSemigroupFileBody$fGenericFileBody$fShowFileBody$fFromJSONFileBody$fGenericFileSegment$fFromJSONFileSegment$fShowFileSegment$fEqFileSegment$fGenericFileFlag$fFromJSONFileFlag$fShowFileFlag $fEqFileFlagApplicationInfomakeApplicationInfowithApplicationValueContext makeContextmakeMultiContextwithName withAnonymous withAttributewithPrivateAttributesgetIndividualContextgetValuegetValueForReference makeConfig configSetKeyconfigSetBaseURIconfigSetStreamURIconfigSetEventsURIconfigSetStoreBackendconfigSetStoreTTLconfigSetStreamingconfigSetInitialRetryDelayconfigSetAllAttributesPrivateconfigSetPrivateAttributeNamesconfigSetFlushIntervalSecondsconfigSetPollIntervalSecondsconfigSetContextKeyLRUCapacityconfigSetUserKeyLRUCapacityconfigSetEventsCapacityconfigSetLoggerconfigSetRequestTimeoutSecondsconfigSetUseLddconfigSetManagerconfigSetApplicationInfoconfigSetOmitAnonymousContexts clientVersion AllFlagsState makeClient getStatus allFlagsStateidentifytracksecureModeHash flushEventsclose boolVariationboolVariationDetailstringVariationstringVariationDetail intVariationintVariationDetaildoubleVariationdoubleVariationDetail jsonVariationjsonVariationDetail$fToJSONFlagState$fToJSONAllFlagsState$fShowAllFlagsState$fGenericAllFlagsState$fShowFlagState$fGenericFlagStatetransitionStatusHttpConfiguration,$sel:defaultRequestHeaders:HttpConfiguration,$sel:defaultRequestTimeout:HttpConfiguration!$sel:tlsManager:HttpConfigurationprepareRequest ClientContext$sel:runLogger:ClientContext$$sel:httpConfiguration:ClientContextisInExperimentOpOpSegmentMatchOpIn OpEndsWith OpStartsWith OpMatches OpContains OpLessThanOpLessThanOrEqual OpGreaterThanOpGreaterThanOrEqualOpBeforeOpAfter OpSemVerEqualOpSemVerLessThanOpSemVerGreaterThan OpUnknown getOperationbaseGHC.Real/ghc-prim GHC.Types~Clause$sel:attribute:Clause$sel:contextKind:Clause$sel:values:Clause$sel:op:Clause$sel:negate:Clause SegmentTarget$sel:contextKind:SegmentTarget$sel:values:SegmentTargetSegment$sel:excludedContexts:Segment$sel:excluded:Segment$sel:includedContexts:Segment$sel:included:Segment$sel:rules:Segment$sel:salt:Segment$sel:deleted:Segment$sel:version:Segment$sel:key:Segment SegmentRule#$sel:rolloutContextKind:SegmentRule$sel:bucketBy:SegmentRule$sel:weight:SegmentRule$sel:clauses:SegmentRule$sel:id:SegmentRule Prerequisite$sel:variation:Prerequisite$sel:key:PrerequisiteFlag $sel:clientSideAvailability:Flag$sel:debugEventsUntilDate:Flag$sel:fallthrough:Flag$sel:rules:Flag$sel:contextTargets:Flag$sel:targets:Flag$sel:prerequisites:Flag $sel:trackEventsFallthrough:Flag$sel:trackEvents:Flag$sel:salt:Flag$sel:deleted:Flag$sel:variations:Flag$sel:offVariation:Flag$sel:version:Flag $sel:on:Flag $sel:key:FlagClientSideAvailability$$sel:explicit:ClientSideAvailability*$sel:usingMobileKey:ClientSideAvailability.$sel:usingEnvironmentId:ClientSideAvailabilityVariationOrRollout$sel:rollout:VariationOrRollout!$sel:variation:VariationOrRolloutRollout$sel:seed:Rollout$sel:bucketBy:Rollout$sel:contextKind:Rollout$sel:kind:Rollout$sel:variations:Rollout RolloutKindRolloutKindRolloutRolloutKindExperimentWeightedVariation $sel:untracked:WeightedVariation$sel:weight:WeightedVariation $sel:variation:WeightedVariationRule$sel:trackEvents:Rule$sel:variationOrRollout:Rule$sel:clauses:Rule $sel:id:RuleTarget$sel:contextKind:Target$sel:variation:Target$sel:values:TargetisClientSideOnlyFlag clearRules clearTargets$aeson-2.2.3.0-G9Z2Jit3h8hFb5zDbTBNRhData.Aeson.Types.ToJSONToJSONData.Aeson.Types.InternalValue$sel:fbKey:FlagBuilder$sel:fbOffVariation:FlagBuilder$sel:fbOn:FlagBuilder'$sel:fbFallthroughVariation:FlagBuilder$sel:fbVariations:FlagBuilder$sel:fbTargetMap:FlagBuilder$sel:fbRules:FlagBuildernewFlagBuilder Variation buildFlag GHC.MaybeNothing Data.EitherLeftbytestring-0.11.5.2Data.ByteString.Internal.Type ByteString VersionedData isInitialized getAllFlagsgetFlag getSegment upsertFlag upsertSegment initialize StoreResultM StoreHandle#$sel:storeHandleGetFlag:StoreHandle&$sel:storeHandleGetSegment:StoreHandle$$sel:storeHandleAllFlags:StoreHandle'$sel:storeHandleInitialized:StoreHandle&$sel:storeHandleInitialize:StoreHandle)$sel:storeHandleUpsertSegment:StoreHandle&$sel:storeHandleUpsertFlag:StoreHandle%$sel:storeHandleExpireAll:StoreHandleLaunchDarklyStoreRead getAllFlagsCgetInitializedCgetFlagC getSegmentCLaunchDarklyStoreWritestoreInitializeCupsertSegmentC upsertFlagCItemDescriptor$sel:value:ItemDescriptor$sel:version:ItemDescriptor makeStoreIO insertFlag deleteFlag insertSegment deleteSegmentinitializeStorecreateSerializedItemDescriptorDataSourceFactorynullDataSourceFactory DataSource'$sel:dataSourceIsInitialized:DataSource$sel:dataSourceStart:DataSource$sel:dataSourceStop:DataSourceDataSourceUpdates,$sel:dataSourceUpdatesInit:DataSourceUpdates2$sel:dataSourceUpdatesInsertFlag:DataSourceUpdates5$sel:dataSourceUpdatesInsertSegment:DataSourceUpdates2$sel:dataSourceUpdatesDeleteFlag:DataSourceUpdates5$sel:dataSourceUpdatesDeleteSegment:DataSourceUpdates1$sel:dataSourceUpdatesSetStatus:DataSourceUpdatesdefaultDataSourceUpdates$sel:key:Config$sel:dataSourceFactory:Config$sel:baseURI:Config$sel:streamURI:Config$sel:eventsURI:Config$sel:storeBackend:Config$sel:storeTTLSeconds:Config$sel:streaming:Config$sel:initialRetryDelay:Config $sel:allAttributesPrivate:Config!$sel:privateAttributeNames:Config $sel:flushIntervalSeconds:Config$sel:pollIntervalSeconds:Config!$sel:contextKeyLRUCapacity:Config$sel:eventsCapacity:Config$sel:logger:Config$sel:sendEvents:Config$sel:offline:Config!$sel:requestTimeoutSeconds:Config$sel:useLdd:Config$sel:manager:Config$sel:applicationInfo:Config!$sel:omitAnonymousContexts:ConfigshouldSendEventsgetApplicationInfoHeaderoptionallyRedactAnonymouswithoutAnonymousContextsSingleInvalidMulti$sel:error:Single SingleContext$sel:key:SingleContext$sel:name:SingleContext$sel:kind:SingleContext$sel:fullKey:SingleContext$sel:anonymous:SingleContext$sel:attributes:SingleContext$$sel:privateAttributes:SingleContext MultiContext$sel:contexts:MultiContext$sel:fullKey:MultiContextgetKeygetKeysgetCanonicalKeygetKinds redactContextredactContextRedactAnonymous EventTypeEventTypeDebugEventTypeIndexEventTypeCustomEventTypeFeatureEventTypeIdentifyEventTypeSummary BaseEvent$sel:creationDate:BaseEvent$sel:event:BaseEvent CustomEvent$sel:metricValue:CustomEvent$sel:contextKeys:CustomEvent$sel:value:CustomEvent$sel:key:CustomEvent DebugEvent FeatureEvent$sel:prereqOf:FeatureEvent$sel:defaultValue:FeatureEvent$sel:variation:FeatureEvent$sel:context:FeatureEvent$sel:version:FeatureEvent$sel:value:FeatureEvent$sel:key:FeatureEvent$sel:reason:FeatureEvent IndexEvent$sel:context:IndexEvent IdentifyEvent$sel:context:IdentifyEvent$sel:key:IdentifyEventCounterContext$sel:variation:CounterContext$sel:unknown:CounterContext$sel:version:CounterContext$sel:count:CounterContext$sel:value:CounterContextFlagSummaryContext$$sel:contextKinds:FlagSummaryContext $sel:counters:FlagSummaryContext$$sel:defaultValue:FlagSummaryContext SummaryEvent$sel:endDate:SummaryEvent$sel:startDate:SummaryEvent$sel:features:SummaryEvent EventKind eventKind EventState$sel:contextKeyLRU:EventState$sel:startDate:EventState$sel:summary:EventState#$sel:lastKnownServerTime:EventState$sel:events:EventState$sel:flush:EventState EvalEvent$sel:debug:EvalEvent!$sel:forceIncludeReason:EvalEvent$sel:prereqOf:EvalEvent$sel:defaultValue:EvalEvent#$sel:debugEventsUntilDate:EvalEvent$sel:trackEvents:EvalEvent$sel:variation:EvalEvent$sel:context:EvalEvent$sel:version:EvalEvent$sel:value:EvalEvent$sel:key:EvalEvent$sel:reason:EvalEventmakeEventState queueEventunixMilliseconds makeBaseEventprocessSummarymakeDebugEventmakeFeatureEvent"makeFeatureEventWithContextPayload fromObjectnewUnknownFlagEventnewSuccessfulEvalEventmakeSummaryKeysummarizeEventputIfEmptyMVar runSummaryprocessEvalEventprocessEvalEventsmaybeIndexContext noticeContext)http-client-0.7.17-AQKf0pqz5ht9yqMF6eM6gpNetwork.HTTP.Client.TypesManager$sel:store:Client$sel:config:Client$sel:status:Client$sel:events:Client$sel:eventThreadPair:Client$sel:dataSource:Client setStatus getStatusIwithResponseGeneric tryAuthorizedcheckAuthorization throwIfNot200 getServerTimetryHTTPaddToALhandleUnauthorizedisHttpUnrecoverablestreamingThread pollingThread eventThreadfst3snd3trd setFallbacksetValueisError evaluateTypedevaluateInternalClient getOffValue getVariationevaluateDetailstatus sequenceUntilcheckPrerequisitescheckPrerequisiteevaluateInternal checkRule checkTargetscheckContextTargetscheckContextTarget checkTarget errorDefault errorDetailgetValueForVariationOrRolloutsetInExperimentruleMatchesContextvariationIndexForContexthexCharToNumberhexStringToNumber bucketContextcalculateBucketValuefloatingOrInteger'bucketableStringValue maybeNegatematchAnyClauseValueclauseMatchesByKindclauseMatchesContextNoSegmentsclauseMatchesContext checkSegmentsegmentRuleMatchesContextsegmentContainsContextcontextKeyInSegmentTargetcontextKeyInTargetListversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDirgetDataFileName getSysconfDir