Nine-language SDK function and return reference

Browse public Launch functions, parameters, successful returns and failures by language. Optional parameters and defaults follow the matching source version.

This page covers Launch account adapters. See the official SDK reference for embedded Licentivo authorization, metering and offline APIs.

Licentivo SDK · Function reference

Session state describes an account only; guard every protected business execution.

Memory storage is the default. Remembered login requires protected persistent storage; account storage and SDK caches are separate.

Restore requires online account confirmation. Launch never chooses offline authorization after network failure; the official SDK verifies offline grants.

Matching source · v0.1.6 · application.go · runtime.go · client.go · store.go

Errors and failures: error != nil; errors.Is(err, launchclient.ErrNoSession); errors.As(err, &apiError)

Connect

Connect(merchantOrigin, productID, licentivoProductID string, trustedKeys map[string]string, options Config) → (*Application, error)

Purpose: Validate public settings and create an application; initialization neither signs in nor authorizes protected work.
Parameters: merchantOrigin / origin: The current store origin, including scheme and required port; use HTTPS in production.
productID / product_id: The Launch store product ID, filled automatically by administration integration code.
licentivoProductID / licentivo_product_id: The Licentivo licensing product ID; it must match public signing configuration.
trustedKeys / trusted_keys: A signing-key-ID to public-key map used to verify official SDK signed grants.
environment: sandbox or live; keep accounts, products and caches in the same environment.
options / config: Optional session storage, private cache directory, cancellation, retries or advanced components.
Returns: (*Application, error)
Return the created object; initialization alone does not establish authorization.

Application.Login

Login(ctx context.Context, email, password string) → (State, error)

Purpose: Sign in with a store account, obtain a short-lived identity assertion and start the official authorization SDK.
Parameters: ctx / ct / signal / cancellation: Request context or cancellation signal; Go's lifecycle context also controls background work.
email, password: The customer's email and password at this store; use the password only for this login.
Returns: (State, error)
Return account state; see the return-field table below.

Application.Restore

Restore(ctx context.Context) → (State, error)

Purpose: Read a saved account session, confirm the account online, obtain a fresh assertion and start the official SDK.
Parameters: ctx / ct / signal / cancellation: Request context or cancellation signal; Go's lifecycle context also controls background work.
Returns: (State, error)
Return account state; ErrNoSession or NO_SESSION means no saved session. Handle other errors separately.

Application.RunFeature

RunFeature(feature string, action func() error) → error

Purpose: The official SDK checks permission on every execution. It runs the callback only when allowed.
Parameters: feature / name, action / block: The feature name must match the policy; the callback contains the actual protected work.
Returns: error
No business return value; normal completion means success, while errors or exceptions report failure.

Application.Logout

Logout(ctx context.Context) → error

Purpose: Stop local authorization, sign out through the official SDK, then revoke the Launch session. Retain unfinished remote tasks for retry.
Parameters: ctx / ct / signal / cancellation: Request context or cancellation signal; Go's lifecycle context also controls background work.
Returns: error
No business return value; normal completion means success, while errors or exceptions report failure.

Application.ReleaseDevice

ReleaseDevice(ctx context.Context) → error

Purpose: Compatibility entry for explicit logout; performs the same account and device logout flow as Logout.
Parameters: ctx / ct / signal / cancellation: Request context or cancellation signal; Go's lifecycle context also controls background work.
Returns: error
No business return value; normal completion means success, while errors or exceptions report failure.

Application.Close

Close() → void

Purpose: Stop this instance and background tasks while preserving remembered login and device binding.
Returns: void
No business return value; ordinary close does not confirm account logout or device release.

Advanced and compatibility APIs

NewApplication

NewApplication(config Config) → (*Application, error)

Purpose: Validate public settings and create an application; initialization neither signs in nor authorizes protected work.
Parameters: options / config: Optional session storage, private cache directory, cancellation, retries or advanced components.
Returns: (*Application, error)
Return the created object; initialization alone does not establish authorization.

NewApplicationFromFiles

NewApplicationFromFiles(launchPath, productPath string, options Config) → (*Application, error)

Purpose: Read two existing public configuration files, validate their product mapping and create an application. Direct connection needs no files.
Parameters: launchPath, productPath: Caller-selected configuration paths or the current user's private cache or storage directory.
options / config: Optional session storage, private cache directory, cancellation, retries or advanced components.
Returns: (*Application, error)
Return the created object; initialization alone does not establish authorization.

LoadPublicConfig

LoadPublicConfig(path string) → (PublicConfig, error)

Purpose: Validate or read public settings; product IDs, environment and signing keys must match.
Parameters: path: Caller-selected configuration paths or the current user's private cache or storage directory.
Returns: (PublicConfig, error)
Return the value type shown in the signature; the result itself grants no feature permission.

NewRuntime

NewRuntime(product ProductConfig, runtime RuntimeConfig) → (Runtime, error)

Purpose: Create an official SDK adapter for advanced integrations; pass the identity assertion only in memory.
Parameters: product, runtime: Configuration, runtime adapter, transport or request objects, supplied only for advanced integrations.
Returns: (Runtime, error)
Return the created object; initialization alone does not establish authorization.

New

New(origin string, allowLocalHTTP bool) → (*Client, error)

Purpose: Validate public settings and create an application; initialization neither signs in nor authorizes protected work.
Parameters: origin: The current store origin, including scheme and required port; use HTTPS in production.
allowLocalHTTP: Optional session storage, private cache directory, cancellation, retries or advanced components.
Returns: (*Client, error)
Return the created object; initialization alone does not establish authorization.

Client.WithToken

WithToken(token string) → *Client

Purpose: Return a client copy carrying the supplied account token, for trusted backends.
Parameters: token: Launch account session token, returned only by low-level session or encrypted-storage interfaces.
Returns: *Client
Return the created object; initialization alone does not establish authorization.

Client.Login

Login(ctx context.Context, email, password string) → (User, error)

Purpose: Authenticate the account and return account details or a session; do not start the authorization runtime.
Parameters: ctx / ct / signal / cancellation: Request context or cancellation signal; Go's lifecycle context also controls background work.
email, password: The customer's email and password at this store; use the password only for this login.
Returns: (User, error)
Return account state; see the return-field table below.

Client.LoginSession

LoginSession(ctx context.Context, email, password string) → (Session, error)

Purpose: Authenticate the account and return account details or a session; do not start the authorization runtime.
Parameters: ctx / ct / signal / cancellation: Request context or cancellation signal; Go's lifecycle context also controls background work.
email, password: The customer's email and password at this store; use the password only for this login.
Returns: (Session, error)
Return account state; see the return-field table below.

Client.CurrentUser

CurrentUser(ctx context.Context) → (User, error)

Purpose: Query current account details; success does not authorize protected work.
Parameters: ctx / ct / signal / cancellation: Request context or cancellation signal; Go's lifecycle context also controls background work.
Returns: (User, error)
Return account state; see the return-field table below.

Client.Identity

Identity(ctx context.Context, product, environment string) → (Identity, error)

Purpose: Obtain a one-use identity assertion and public routing context; neither is a license or feature grant.
Parameters: ctx / ct / signal / cancellation: Request context or cancellation signal; Go's lifecycle context also controls background work.
product: The Launch store product ID, filled automatically by administration integration code.
environment: sandbox or live; keep accounts, products and caches in the same environment.
Returns: (Identity, error)
Return account state; see the return-field table below.

Client.SignOut

SignOut(ctx context.Context) → error

Purpose: Revoke the Launch session and clear this client's token; this alone does not perform official SDK device logout.
Parameters: ctx / ct / signal / cancellation: Request context or cancellation signal; Go's lifecycle context also controls background work.
Returns: error
No business return value; normal completion means success, while errors or exceptions report failure.

Client.Credential

Credential(ctx context.Context, product, environment string) → (Credential, error)

Purpose: Retained legacy API; the long-term license credential protocol was removed, so calls fail. Use Application for new integrations.
Parameters: ctx / ct / signal / cancellation: Request context or cancellation signal; Go's lifecycle context also controls background work.
product: The Launch store product ID, filled automatically by administration integration code.
environment: sandbox or live; keep accounts, products and caches in the same environment.
Returns: (Credential, error)
Always fails; migrate to account identity exchange.

Client.CredentialWithRetry

CredentialWithRetry(ctx context.Context, product, environment string, policy RetryPolicy) → (Credential, error)

Purpose: Retained legacy API; the long-term license credential protocol was removed, so calls fail. Use Application for new integrations.
Parameters: ctx / ct / signal / cancellation: Request context or cancellation signal; Go's lifecycle context also controls background work.
product: The Launch store product ID, filled automatically by administration integration code.
environment: sandbox or live; keep accounts, products and caches in the same environment.
policy: Optional session storage, private cache directory, cancellation, retries or advanced components.
Returns: (Credential, error)
Always fails; migrate to account identity exchange.

NewSystemSessionStore

NewSystemSessionStore(directory string) → (SessionStore, error)

Purpose: Create protected persistent session storage; obtain its encryption key from the operating system credential vault.
Parameters: directory: Caller-selected configuration paths or the current user's private cache or storage directory.
Returns: (SessionStore, error)
Return the created object; initialization alone does not establish authorization.

ProtectDirectory

ProtectDirectory(directory string) → error

Purpose: Restrict directory access to the current Windows user or private directory permissions on other platforms.
Parameters: directory: Caller-selected configuration paths or the current user's private cache or storage directory.
Returns: error
No business return value; normal completion means success, while errors or exceptions report failure.

ServiceUnavailable

ServiceUnavailable(err error) → bool

Purpose: Classify temporary service unavailability; this alone never permits offline authorization.
Parameters: err: Create or read structured errors for classification, backoff and troubleshooting correlation.
Returns: bool
Return a Boolean classification, not an authorization grant.

APIError.Error / TransportError.Error

Error() → string

Purpose: Create or read structured errors for classification, backoff and troubleshooting correlation.
Returns: string
Return the value type shown in the signature; the result itself grants no feature permission.

TransportError.Unwrap

Unwrap() → error

Purpose: Create or read structured errors for classification, backoff and troubleshooting correlation.
Returns: error
Return the value type shown in the signature; the result itself grants no feature permission.

MemoryStore.Load / SessionStore.Load

Load(ctx context.Context, key string) → ([]byte, error)

Purpose: Load an account record by isolated key; it contains secrets and belongs only in the SDK.
Parameters: scope / key, value / record: SDK isolation keys and secret records; custom storage must support multiple keys and atomic replacement.
Returns: ([]byte, error)
Return the secret record; absence yields an empty value or ErrNoSession according to the language contract.

MemoryStore.Save / SessionStore.Save

Save(ctx context.Context, key string, value []byte) → error

Purpose: Atomically save an account record under its isolated key.
Parameters: scope / key, value / record: SDK isolation keys and secret records; custom storage must support multiple keys and atomic replacement.
Returns: error
No business return value; normal completion means success, while errors or exceptions report failure.

MemoryStore.Delete / SessionStore.Delete

Delete(ctx context.Context, key string) → error

Purpose: Delete the account record, preserving official SDK authorization caches and logout journals.
Parameters: scope / key, value / record: SDK isolation keys and secret records; custom storage must support multiple keys and atomic replacement.
Returns: error
No business return value; normal completion means success, while errors or exceptions report failure.

Runtime.Start

Start(ctx context.Context, onError func(error)) → error

Purpose: Start official SDK verification and background maintenance; use separate account-login and feature-guard APIs.
Parameters: ctx / ct / signal / cancellation: Request context or cancellation signal; Go's lifecycle context also controls background work.
onError: Create or read structured errors for classification, backoff and troubleshooting correlation.
Returns: error
No business return value; normal completion means success, while errors or exceptions report failure.

Runtime.RunFeature

RunFeature(feature string, action func() error) → error

Purpose: The official SDK checks permission on every execution. It runs the callback only when allowed.
Parameters: feature / name, action / block: The feature name must match the policy; the callback contains the actual protected work.
Returns: error
No business return value; normal completion means success, while errors or exceptions report failure.

Runtime.Deactivate

Deactivate(ctx context.Context) → error

Purpose: Perform official SDK device logout; the application separately revokes the Launch account session.
Parameters: ctx / ct / signal / cancellation: Request context or cancellation signal; Go's lifecycle context also controls background work.
Returns: error
No business return value; normal completion means success, while errors or exceptions report failure.

Runtime.Close

Close() → void

Purpose: Stop this instance and background tasks while preserving remembered login and device binding.
Returns: void
No business return value; ordinary close does not confirm account logout or device release.

Python

Matching source · v0.1.6 · client.py

Errors and failures: APIError.code / .status / .retry_after / .retryable; ValueError; SDK exceptions

Application.connect

Application.connect(merchant_origin, product_id, licentivo_product_id, trusted_keys, environment="live", **kwargs) → Application

Purpose: Validate public settings and create an application; initialization neither signs in nor authorizes protected work.
Parameters: merchantOrigin / origin: The current store origin, including scheme and required port; use HTTPS in production.
productID / product_id: The Launch store product ID, filled automatically by administration integration code.
licentivoProductID / licentivo_product_id: The Licentivo licensing product ID; it must match public signing configuration.
trustedKeys / trusted_keys: A signing-key-ID to public-key map used to verify official SDK signed grants.
environment: sandbox or live; keep accounts, products and caches in the same environment.
options / config: Optional session storage, private cache directory, cancellation, retries or advanced components.
Returns: Application
Return the created object; initialization alone does not establish authorization.

Application.login

login(email, password, *, pending_attempts=3) → Application (self)

Purpose: Sign in with a store account, obtain a short-lived identity assertion and start the official authorization SDK.
Parameters: email, password: The customer's email and password at this store; use the password only for this login.
pending_attempts: Optional session storage, private cache directory, cancellation, retries or advanced components.
Returns: Application (self)
Return this application instance, not account details or an authorization result.

Application.restore

restore() → bool

Purpose: Read a saved account session, confirm the account online, obtain a fresh assertion and start the official SDK.
Returns: bool
true means restored; false means no restorable session. Denial, expiry and network failures report errors.

Application.run_feature

run_feature(name, action) → T

Purpose: The official SDK checks permission on every execution. It runs the callback only when allowed.
Parameters: feature / name, action / block: The feature name must match the policy; the callback contains the actual protected work.
Returns: T
Return the business callback's result; authorization failures and business exceptions report errors.

Application.logout

logout() → bool

Purpose: Stop local authorization, sign out through the official SDK, then revoke the Launch session. Retain unfinished remote tasks for retry.
Returns: bool
true confirms logout; false means remote account logout or device revocation is pending. Storage failures may still raise errors.

Application.release_device

release_device() → bool

Purpose: Compatibility entry for explicit logout; performs the same account and device logout flow as Logout.
Returns: bool
true confirms logout; false means remote account logout or device revocation is pending. Storage failures may still raise errors.

Application.close

close() → None

Purpose: Stop this instance and background tasks while preserving remembered login and device binding.
Returns: None
No business return value; ordinary close does not confirm account logout or device release.

Application.__enter__ / __exit__

with Application.connect(...) as app: ... → Application / None

Purpose: Stop this instance and background tasks while preserving remembered login and device binding.
Returns: Application / None
No business return value; ordinary close does not confirm account logout or device release.

Advanced and compatibility APIs

Application.__init__

Application(origin, product_id, product_config, environment="live", store=None, runtime_factory=None, cache_dir=None, sleep=time.sleep, opener=None) → Application

Purpose: Validate public settings and create an application; initialization neither signs in nor authorizes protected work.
Parameters: origin: The current store origin, including scheme and required port; use HTTPS in production.
product_id: The Launch store product ID, filled automatically by administration integration code.
product_config: Configuration, runtime adapter, transport or request objects, supplied only for advanced integrations.
environment: sandbox or live; keep accounts, products and caches in the same environment.
options / config: Optional session storage, private cache directory, cancellation, retries or advanced components.
Returns: Application
Return the created object; initialization alone does not establish authorization.

Application.from_files

Application.from_files(launch_config, product_config, **kwargs) → Application

Purpose: Read two existing public configuration files, validate their product mapping and create an application. Direct connection needs no files.
Parameters: launch_config, product_config: Caller-selected configuration paths or the current user's private cache or storage directory.
options / config: Optional session storage, private cache directory, cancellation, retries or advanced components.
Returns: Application
Return the created object; initialization alone does not establish authorization.

MemoryStore

MemoryStore() → MemoryStore

Purpose: Create session storage valid only within this process.
Returns: MemoryStore
Return the created object; initialization alone does not establish authorization.

WindowsDPAPIStore

WindowsDPAPIStore(directory=None) → WindowsDPAPIStore

Purpose: Create protected persistent session storage; obtain its encryption key from the operating system credential vault.
Parameters: directory: Caller-selected configuration paths or the current user's private cache or storage directory.
Returns: WindowsDPAPIStore
Return the created object; initialization alone does not establish authorization.

APIError

APIError(code, status=0, retry_after=0) → APIError

Purpose: Create or read structured errors for classification, backoff and troubleshooting correlation.
Parameters: code, status, retry_after: Create or read structured errors for classification, backoff and troubleshooting correlation.
Returns: APIError
Return the value type shown in the signature; the result itself grants no feature permission.

MemoryStore.load / WindowsDPAPIStore.load

load(key) → bytes | None

Purpose: Load an account record by isolated key; it contains secrets and belongs only in the SDK.
Parameters: scope / key, value / record: SDK isolation keys and secret records; custom storage must support multiple keys and atomic replacement.
Returns: bytes | None
Return the secret record; absence yields an empty value or ErrNoSession according to the language contract.

MemoryStore.save / WindowsDPAPIStore.save

save(key, value) → None

Purpose: Atomically save an account record under its isolated key.
Parameters: scope / key, value / record: SDK isolation keys and secret records; custom storage must support multiple keys and atomic replacement.
Returns: None
No business return value; normal completion means success, while errors or exceptions report failure.

MemoryStore.delete / WindowsDPAPIStore.delete

delete(key) → None

Purpose: Delete the account record, preserving official SDK authorization caches and logout journals.
Parameters: scope / key, value / record: SDK isolation keys and secret records; custom storage must support multiple keys and atomic replacement.
Returns: None
No business return value; normal completion means success, while errors or exceptions report failure.

Matching source · v0.1.6 · Application.cs · SessionStore.cs

Errors and failures: await Task / ValueTask; LaunchException.Code / .Status / .RetryAfterSeconds / .Retryable

Application.Connect

Application.Connect(string merchantOrigin, string productId, string licentivoProductId, Dictionary<string,string> trustedKeys, string environment="live", ISessionStore? store=null, string? cacheDirectory=null) → Application

Purpose: Validate public settings and create an application; initialization neither signs in nor authorizes protected work.
Parameters: merchantOrigin / origin: The current store origin, including scheme and required port; use HTTPS in production.
productID / product_id: The Launch store product ID, filled automatically by administration integration code.
licentivoProductID / licentivo_product_id: The Licentivo licensing product ID; it must match public signing configuration.
trustedKeys / trusted_keys: A signing-key-ID to public-key map used to verify official SDK signed grants.
environment: sandbox or live; keep accounts, products and caches in the same environment.
store, cacheDirectory: Optional session storage, private cache directory, cancellation, retries or advanced components.
Returns: Application
Return the created object; initialization alone does not establish authorization.

Application.Login

Login(string email, string password, int pendingAttempts=3, CancellationToken ct=default) → Task

Purpose: Sign in with a store account, obtain a short-lived identity assertion and start the official authorization SDK.
Parameters: email, password: The customer's email and password at this store; use the password only for this login.
pendingAttempts: Optional session storage, private cache directory, cancellation, retries or advanced components.
ctx / ct / signal / cancellation: Request context or cancellation signal; Go's lifecycle context also controls background work.
Returns: Task
No business return value; normal completion means success, while errors or exceptions report failure.

Application.Restore

Restore(CancellationToken ct=default) → Task<bool>

Purpose: Read a saved account session, confirm the account online, obtain a fresh assertion and start the official SDK.
Parameters: ctx / ct / signal / cancellation: Request context or cancellation signal; Go's lifecycle context also controls background work.
Returns: Task<bool>
true means restored; false means no restorable session. Denial, expiry and network failures report errors.

Application.RunFeature

RunFeature(string feature, Func<Task> action) → Task

Purpose: The official SDK checks permission on every execution. It runs the callback only when allowed.
Parameters: feature / name, action / block: The feature name must match the policy; the callback contains the actual protected work.
Returns: Task
No business return value; normal completion means success, while errors or exceptions report failure.

Application.Status

Status() → AuthorizationStatus? (null: runtime absent)

Purpose: Read current official SDK authorization status. This neither signs in nor replaces permission checks around protected work.
Returns: AuthorizationStatus? (null: runtime absent)
Read current official SDK authorization status. This neither signs in nor replaces permission checks around protected work.

Application.Logout

Logout(CancellationToken ct=default) → Task

Purpose: Stop local authorization, sign out through the official SDK, then revoke the Launch session. Retain unfinished remote tasks for retry.
Parameters: ctx / ct / signal / cancellation: Request context or cancellation signal; Go's lifecycle context also controls background work.
Returns: Task
No business return value; normal completion means success, while errors or exceptions report failure.

Application.ReleaseDevice

ReleaseDevice(CancellationToken ct=default) → Task

Purpose: Compatibility entry for explicit logout; performs the same account and device logout flow as Logout.
Parameters: ctx / ct / signal / cancellation: Request context or cancellation signal; Go's lifecycle context also controls background work.
Returns: Task
No business return value; normal completion means success, while errors or exceptions report failure.

Application.DisposeAsync

DisposeAsync() → ValueTask

Purpose: Stop this instance and background tasks while preserving remembered login and device binding.
Returns: ValueTask
No business return value; ordinary close does not confirm account logout or device release.

Advanced and compatibility APIs

Application

Application(string origin, string productId, Config productConfig, string environment="live", ISessionStore? store=null, string? cacheDirectory=null, HttpMessageHandler? handler=null, Func<Config,IRuntime>? runtimeFactory=null) → Application

Purpose: Validate public settings and create an application; initialization neither signs in nor authorizes protected work.
Parameters: origin: The current store origin, including scheme and required port; use HTTPS in production.
productId: The Launch store product ID, filled automatically by administration integration code.
productConfig: Configuration, runtime adapter, transport or request objects, supplied only for advanced integrations.
environment: sandbox or live; keep accounts, products and caches in the same environment.
options / config: Optional session storage, private cache directory, cancellation, retries or advanced components.
Returns: Application
Return the created object; initialization alone does not establish authorization.

Application.FromFiles

Application.FromFiles(string launchPath, string productPath, ISessionStore? store=null) → Application

Purpose: Read two existing public configuration files, validate their product mapping and create an application. Direct connection needs no files.
Parameters: launchPath, productPath: Caller-selected configuration paths or the current user's private cache or storage directory.
store: Optional session storage, private cache directory, cancellation, retries or advanced components.
Returns: Application
Return the created object; initialization alone does not establish authorization.

MemoryStore

new MemoryStore() → MemoryStore

Purpose: Create session storage valid only within this process.
Returns: MemoryStore
Return the created object; initialization alone does not establish authorization.

WindowsDPAPIStore

new WindowsDPAPIStore(string? directory=null) → WindowsDPAPIStore

Purpose: Create protected persistent session storage; obtain its encryption key from the operating system credential vault.
Parameters: directory: Caller-selected configuration paths or the current user's private cache or storage directory.
Returns: WindowsDPAPIStore
Return the created object; initialization alone does not establish authorization.

LaunchException

new LaunchException(string code, int status=0, int retryAfterSeconds=0) → LaunchException

Purpose: Create or read structured errors for classification, backoff and troubleshooting correlation.
Parameters: code, status, retryAfterSeconds: Create or read structured errors for classification, backoff and troubleshooting correlation.
Returns: LaunchException
Return the value type shown in the signature; the result itself grants no feature permission.

ISessionStore.Load / MemoryStore.Load / WindowsDPAPIStore.Load

Load(string key) → byte[]?

Purpose: Load an account record by isolated key; it contains secrets and belongs only in the SDK.
Parameters: scope / key, value / record: SDK isolation keys and secret records; custom storage must support multiple keys and atomic replacement.
Returns: byte[]?
Return the secret record; absence yields an empty value or ErrNoSession according to the language contract.

ISessionStore.Save / MemoryStore.Save / WindowsDPAPIStore.Save

Save(string key, byte[] value) → void

Purpose: Atomically save an account record under its isolated key.
Parameters: scope / key, value / record: SDK isolation keys and secret records; custom storage must support multiple keys and atomic replacement.
Returns: void
No business return value; normal completion means success, while errors or exceptions report failure.

ISessionStore.Delete / MemoryStore.Delete / WindowsDPAPIStore.Delete

Delete(string key) → void

Purpose: Delete the account record, preserving official SDK authorization caches and logout journals.
Parameters: scope / key, value / record: SDK isolation keys and secret records; custom storage must support multiple keys and atomic replacement.
Returns: void
No business return value; normal completion means success, while errors or exceptions report failure.

IRuntime.Start

Start(CancellationToken ct) → Task

Purpose: Start official SDK verification and background maintenance; use separate account-login and feature-guard APIs.
Parameters: ctx / ct / signal / cancellation: Request context or cancellation signal; Go's lifecycle context also controls background work.
Returns: Task
No business return value; normal completion means success, while errors or exceptions report failure.

IRuntime.Status

Status() → AuthorizationStatus

Purpose: Read current official SDK authorization status. This neither signs in nor replaces permission checks around protected work.
Returns: AuthorizationStatus
Read current official SDK authorization status. This neither signs in nor replaces permission checks around protected work.

IRuntime.RunFeature

RunFeature(string feature, Func<Task> action) → Task

Purpose: The official SDK checks permission on every execution. It runs the callback only when allowed.
Parameters: feature / name, action / block: The feature name must match the policy; the callback contains the actual protected work.
Returns: Task
No business return value; normal completion means success, while errors or exceptions report failure.

IRuntime.Deactivate

Deactivate(CancellationToken ct) → Task

Purpose: Perform official SDK device logout; the application separately revokes the Launch account session.
Parameters: ctx / ct / signal / cancellation: Request context or cancellation signal; Go's lifecycle context also controls background work.
Returns: Task
No business return value; normal completion means success, while errors or exceptions report failure.

IRuntime.DisposeAsync

DisposeAsync() → ValueTask

Purpose: Stop this instance and background tasks while preserving remembered login and device binding.
Returns: ValueTask
No business return value; ordinary close does not confirm account logout or device release.

Java

Matching source · v0.1.6 · Launch.java · EncryptedFileStore.java

Errors and failures: throws Exception; Launch.Failure.code / .status / .requestID / .retryAfterMillis / .transport; char[] password

Launch.connect

Launch.connect(String merchantOrigin, String productId, String licentivoProductId, Map<String,String> trustedKeys, String environment) → Launch

Purpose: Validate public settings and create an application; initialization neither signs in nor authorizes protected work.
Parameters: merchantOrigin / origin: The current store origin, including scheme and required port; use HTTPS in production.
productID / product_id: The Launch store product ID, filled automatically by administration integration code.
licentivoProductID / licentivo_product_id: The Licentivo licensing product ID; it must match public signing configuration.
trustedKeys / trusted_keys: A signing-key-ID to public-key map used to verify official SDK signed grants.
environment: sandbox or live; keep accounts, products and caches in the same environment.
Returns: Launch
Return the created object; initialization alone does not establish authorization.

Launch.login

login(String email, char[] password) → State

Purpose: Sign in with a store account, obtain a short-lived identity assertion and start the official authorization SDK.
Parameters: email, password: The customer's email and password at this store; use the password only for this login.
Returns: State
Return account state; see the return-field table below.

Launch.restore

restore() → State

Purpose: Read a saved account session, confirm the account online, obtain a fresh assertion and start the official SDK.
Returns: State
Return account state; ErrNoSession or NO_SESSION means no saved session. Handle other errors separately.

Launch.runFeature

runFeature(String feature, Client.FeatureAction action) → void

Purpose: The official SDK checks permission on every execution. It runs the callback only when allowed.
Parameters: feature / name, action / block: The feature name must match the policy; the callback contains the actual protected work.
Returns: void
No business return value; normal completion means success, while errors or exceptions report failure.

Launch.logout

logout() → void

Purpose: Stop local authorization, sign out through the official SDK, then revoke the Launch session. Retain unfinished remote tasks for retry.
Returns: void
No business return value; normal completion means success, while errors or exceptions report failure.

Launch.releaseDevice

releaseDevice() → void

Purpose: Compatibility entry for explicit logout; performs the same account and device logout flow as Logout.
Returns: void
No business return value; normal completion means success, while errors or exceptions report failure.

Launch.close

close() → void

Purpose: Stop this instance and background tasks while preserving remembered login and device binding.
Returns: void
No business return value; ordinary close does not confirm account logout or device release.

Advanced and compatibility APIs

Launch

new Launch(Config config, Map<String,Object> product, Path cacheRoot [, Store store, Transport transport, RuntimeFactory factory, Sleeper sleeper]) → Launch

Purpose: Validate public settings and create an application; initialization neither signs in nor authorizes protected work.
Parameters: config, product: Configuration, runtime adapter, transport or request objects, supplied only for advanced integrations.
cacheRoot: Caller-selected configuration paths or the current user's private cache or storage directory.
store, transport, factory, sleeper: Optional session storage, private cache directory, cancellation, retries or advanced components.
Returns: Launch
Return the created object; initialization alone does not establish authorization.

Launch.Config

new Launch.Config(String merchantOrigin, String launchProductID, String licentivoProductID, String environment) → Config

Purpose: Validate or read public settings; product IDs, environment and signing keys must match.
Parameters: merchantOrigin / origin: The current store origin, including scheme and required port; use HTTPS in production.
productID / product_id: The Launch store product ID, filled automatically by administration integration code.
licentivoProductID / licentivo_product_id: The Licentivo licensing product ID; it must match public signing configuration.
environment: sandbox or live; keep accounts, products and caches in the same environment.
Returns: Config
Return the value type shown in the signature; the result itself grants no feature permission.

Launch.Config.load

Launch.Config.load(Path path) → Config

Purpose: Validate or read public settings; product IDs, environment and signing keys must match.
Parameters: path: Caller-selected configuration paths or the current user's private cache or storage directory.
Returns: Config
Return the value type shown in the signature; the result itself grants no feature permission.

Launch.readPublic

Launch.readPublic(Path path) → Map<String,Object>

Purpose: Validate or read public settings; product IDs, environment and signing keys must match.
Parameters: path: Caller-selected configuration paths or the current user's private cache or storage directory.
Returns: Map<String,Object>
Return the value type shown in the signature; the result itself grants no feature permission.

Launch.MemoryStore

new Launch.MemoryStore() → MemoryStore

Purpose: Create session storage valid only within this process.
Returns: MemoryStore
Return the created object; initialization alone does not establish authorization.

EncryptedFileStore

new EncryptedFileStore(Path directory, SecretKey vaultKey) → EncryptedFileStore

Purpose: Create protected persistent session storage; obtain its encryption key from the operating system credential vault.
Parameters: directory: Caller-selected configuration paths or the current user's private cache or storage directory.
vaultKey: An encryption key from the operating system credential vault; never store it beside encrypted records.
Returns: EncryptedFileStore
Return the created object; initialization alone does not establish authorization.

Launch.HTTPTransport.request

request(String method, URI uri, String bearer, byte[] body) → Response

Purpose: Send account HTTP requests and return status, headers or raw body; make no authorization decision.
Parameters: method, uri, bearer, body: Configuration, runtime adapter, transport or request objects, supplied only for advanced integrations.
Returns: Response
Return the value type shown in the signature; the result itself grants no feature permission.

Launch.Failure

new Launch.Failure(String code [, int status, String requestID, long retryAfterMillis, boolean transport]) → Failure

Purpose: Create or read structured errors for classification, backoff and troubleshooting correlation.
Parameters: code, status, requestID, retryAfterMillis, transport: Create or read structured errors for classification, backoff and troubleshooting correlation.
Returns: Failure
Return the value type shown in the signature; the result itself grants no feature permission.

Launch.Failure.unavailable

unavailable() → boolean

Purpose: Classify temporary service unavailability; this alone never permits offline authorization.
Returns: boolean
Return a Boolean classification, not an authorization grant.

Store.load / MemoryStore.load / EncryptedFileStore.load

load(String scope) → byte[] | null

Purpose: Load an account record by isolated key; it contains secrets and belongs only in the SDK.
Parameters: scope / key, value / record: SDK isolation keys and secret records; custom storage must support multiple keys and atomic replacement.
Returns: byte[] | null
Return the secret record; absence yields an empty value or ErrNoSession according to the language contract.

Store.save / MemoryStore.save / EncryptedFileStore.save

save(String scope, byte[] secret) → void

Purpose: Atomically save an account record under its isolated key.
Parameters: scope / key, value / record: SDK isolation keys and secret records; custom storage must support multiple keys and atomic replacement.
Returns: void
No business return value; normal completion means success, while errors or exceptions report failure.

Store.delete / MemoryStore.delete / EncryptedFileStore.delete

delete(String scope) → void

Purpose: Delete the account record, preserving official SDK authorization caches and logout journals.
Parameters: scope / key, value / record: SDK isolation keys and secret records; custom storage must support multiple keys and atomic replacement.
Returns: void
No business return value; normal completion means success, while errors or exceptions report failure.

Runtime.canStartOffline

canStartOffline() → boolean

Purpose: Read current official SDK authorization status. This neither signs in nor replaces permission checks around protected work.
Returns: boolean
Return a Boolean classification, not an authorization grant.

Runtime.start

start() → void

Purpose: Start official SDK verification and background maintenance; use separate account-login and feature-guard APIs.
Returns: void
No business return value; normal completion means success, while errors or exceptions report failure.

Runtime.runFeature

runFeature(String feature, Client.FeatureAction action) → void

Purpose: The official SDK checks permission on every execution. It runs the callback only when allowed.
Parameters: feature / name, action / block: The feature name must match the policy; the callback contains the actual protected work.
Returns: void
No business return value; normal completion means success, while errors or exceptions report failure.

Runtime.releaseDevice

releaseDevice() → void

Purpose: Perform official SDK device logout; the application separately revokes the Launch account session.
Returns: void
No business return value; normal completion means success, while errors or exceptions report failure.

Runtime.close

close() → void

Purpose: Stop this instance and background tasks while preserving remembered login and device binding.
Returns: void
No business return value; ordinary close does not confirm account logout or device release.

RuntimeFactory.create

create(Map<String,Object> settings) → Runtime

Purpose: Create an official SDK adapter for advanced integrations; pass the identity assertion only in memory.
Parameters: settings: Configuration, runtime adapter, transport or request objects, supplied only for advanced integrations.
Returns: Runtime
Return the created object; initialization alone does not establish authorization.

Sleeper.sleep

sleep(long milliseconds) → void

Purpose: Wait for the specified duration for advanced retry scheduling.
Parameters: milliseconds: Suggested retry delay; observe language differences between seconds, milliseconds and Duration.
Returns: void
No business return value; normal completion means success, while errors or exceptions report failure.

JavaScript / TypeScript

Matching source · v0.1.6 · index.d.ts · index.mjs

Errors and failures: await Promise; catch (error); LaunchError(code, status, retryAfterSeconds)

Application.connect

Application.connect(merchantOrigin, productID, licentivoProductID, trustedKeys, options?) → Application

Purpose: Validate public settings and create an application; initialization neither signs in nor authorizes protected work.
Parameters: merchantOrigin / origin: The current store origin, including scheme and required port; use HTTPS in production.
productID / product_id: The Launch store product ID, filled automatically by administration integration code.
licentivoProductID / licentivo_product_id: The Licentivo licensing product ID; it must match public signing configuration.
trustedKeys / trusted_keys: A signing-key-ID to public-key map used to verify official SDK signed grants.
environment: sandbox or live; keep accounts, products and caches in the same environment.
options / config: Optional session storage, private cache directory, cancellation, retries or advanced components.
Returns: Application
Return the created object; initialization alone does not establish authorization.

Application.login

login(email: string, password: string, options?: {signal?: AbortSignal}) → Promise<SessionState>

Purpose: Sign in with a store account, obtain a short-lived identity assertion and start the official authorization SDK.
Parameters: email, password: The customer's email and password at this store; use the password only for this login.
ctx / ct / signal / cancellation: Request context or cancellation signal; Go's lifecycle context also controls background work.
Returns: Promise<SessionState>
Return account state; see the return-field table below.

Application.restore

restore(options?: {signal?: AbortSignal}) → Promise<SessionState | null>

Purpose: Read a saved account session, confirm the account online, obtain a fresh assertion and start the official SDK.
Parameters: ctx / ct / signal / cancellation: Request context or cancellation signal; Go's lifecycle context also controls background work.
Returns: Promise<SessionState | null>
Return account state; null or nil means no restorable session. Other failures report errors.

Application.runFeature

runFeature<T>(name: string, action: () => T | Promise<T>) → Promise<T>

Purpose: The official SDK checks permission on every execution. It runs the callback only when allowed.
Parameters: feature / name, action / block: The feature name must match the policy; the callback contains the actual protected work.
Returns: Promise<T>
Return the business callback's result; authorization failures and business exceptions report errors.

Application.logout

logout(options?: {signal?: AbortSignal}) → Promise<boolean>

Purpose: Stop local authorization, sign out through the official SDK, then revoke the Launch session. Retain unfinished remote tasks for retry.
Parameters: ctx / ct / signal / cancellation: Request context or cancellation signal; Go's lifecycle context also controls background work.
Returns: Promise<boolean>
true confirms logout; false means remote account logout or device revocation is pending. Storage failures may still raise errors.

Application.releaseDevice

releaseDevice(options?: {signal?: AbortSignal}) → Promise<void>

Purpose: Compatibility entry for explicit logout; performs the same account and device logout flow as Logout.
Parameters: ctx / ct / signal / cancellation: Request context or cancellation signal; Go's lifecycle context also controls background work.
Returns: Promise<void>
No business return value; normal completion means success, while errors or exceptions report failure.

Application.close

close() → Promise<void>

Purpose: Stop this instance and background tasks while preserving remembered login and device binding.
Returns: Promise<void>
No business return value; ordinary close does not confirm account logout or device release.

Advanced and compatibility APIs

Application

new Application(launch: LaunchConfig, product: PublicProductConfig, options?: Options) → Application

Purpose: Validate public settings and create an application; initialization neither signs in nor authorizes protected work.
Parameters: launch, product: Configuration, runtime adapter, transport or request objects, supplied only for advanced integrations.
options / config: Optional session storage, private cache directory, cancellation, retries or advanced components.
Returns: Application
Return the created object; initialization alone does not establish authorization.

Application.fromFiles

Application.fromFiles(launchPath: string, productPath: string, options?: Options) → Promise<Application>

Purpose: Read two existing public configuration files, validate their product mapping and create an application. Direct connection needs no files.
Parameters: launchPath, productPath: Caller-selected configuration paths or the current user's private cache or storage directory.
options / config: Optional session storage, private cache directory, cancellation, retries or advanced components.
Returns: Promise<Application>
Return the created object; initialization alone does not establish authorization.

validateConfig

validateConfig(launch: LaunchConfig, product: PublicProductConfig) → {launch: LaunchConfig, product: PublicProductConfig}

Purpose: Validate or read public settings; product IDs, environment and signing keys must match.
Parameters: launch, product: Configuration, runtime adapter, transport or request objects, supplied only for advanced integrations.
Returns: {launch: LaunchConfig, product: PublicProductConfig}
Return the value type shown in the signature; the result itself grants no feature permission.

loadConfig

loadConfig(launchPath: string, productPath: string) → Promise<{launch: LaunchConfig, product: PublicProductConfig}>

Purpose: Validate or read public settings; product IDs, environment and signing keys must match.
Parameters: launchPath, productPath: Caller-selected configuration paths or the current user's private cache or storage directory.
Returns: Promise<{launch: LaunchConfig, product: PublicProductConfig}>
Return the value type shown in the signature; the result itself grants no feature permission.

defaultTransport

defaultTransport(request: Request) → Promise<Response>

Purpose: Send account HTTP requests and return status, headers or raw body; make no authorization decision.
Parameters: request: Configuration, runtime adapter, transport or request objects, supplied only for advanced integrations.
Returns: Promise<Response>
Return the value type shown in the signature; the result itself grants no feature permission.

MemoryStore

new MemoryStore() → MemoryStore

Purpose: Create session storage valid only within this process.
Returns: MemoryStore
Return the created object; initialization alone does not establish authorization.

EncryptedFileStore

new EncryptedFileStore(directory: string, key: Uint8Array) → EncryptedFileStore

Purpose: Create protected persistent session storage; obtain its encryption key from the operating system credential vault.
Parameters: directory: Caller-selected configuration paths or the current user's private cache or storage directory.
key: An encryption key from the operating system credential vault; never store it beside encrypted records.
Returns: EncryptedFileStore
Return the created object; initialization alone does not establish authorization.

LaunchError

new LaunchError(code: string, status=0, retryAfterSeconds=0) → LaunchError

Purpose: Create or read structured errors for classification, backoff and troubleshooting correlation.
Parameters: code, status, retryAfterSeconds: Create or read structured errors for classification, backoff and troubleshooting correlation.
Returns: LaunchError
Return the value type shown in the signature; the result itself grants no feature permission.

SessionStore.load / MemoryStore.load / EncryptedFileStore.load

load(scope: string) → Promise<SavedSession | null>

Purpose: Load an account record by isolated key; it contains secrets and belongs only in the SDK.
Parameters: scope / key, value / record: SDK isolation keys and secret records; custom storage must support multiple keys and atomic replacement.
Returns: Promise<SavedSession | null>
Return the secret record; absence yields an empty value or ErrNoSession according to the language contract.

SessionStore.save / MemoryStore.save / EncryptedFileStore.save

save(scope: string, value: SavedSession) → Promise<void>

Purpose: Atomically save an account record under its isolated key.
Parameters: scope / key, value / record: SDK isolation keys and secret records; custom storage must support multiple keys and atomic replacement.
Returns: Promise<void>
No business return value; normal completion means success, while errors or exceptions report failure.

SessionStore.delete / MemoryStore.delete / EncryptedFileStore.delete

delete(scope: string) → Promise<void>

Purpose: Delete the account record, preserving official SDK authorization caches and logout journals.
Parameters: scope / key, value / record: SDK isolation keys and secret records; custom storage must support multiple keys and atomic replacement.
Returns: Promise<void>
No business return value; normal completion means success, while errors or exceptions report failure.

Runtime.status

status() → {allowed:boolean,state:string} | Promise<{allowed:boolean,state:string}>

Purpose: Read current official SDK authorization status. This neither signs in nor replaces permission checks around protected work.
Returns: {allowed:boolean,state:string} | Promise<{allowed:boolean,state:string}>
Read current official SDK authorization status. This neither signs in nor replaces permission checks around protected work.

Runtime.start

start(onError?: (error: unknown) => void, signal?: AbortSignal) → Promise<unknown>

Purpose: Start official SDK verification and background maintenance; use separate account-login and feature-guard APIs.
Parameters: onError: Create or read structured errors for classification, backoff and troubleshooting correlation.
ctx / ct / signal / cancellation: Request context or cancellation signal; Go's lifecycle context also controls background work.
Returns: Promise<unknown>
No business return value; normal completion means success, while errors or exceptions report failure.

Runtime.runFeature

runFeature<T>(name: string, action: () => T | Promise<T>) → Promise<T>

Purpose: The official SDK checks permission on every execution. It runs the callback only when allowed.
Parameters: feature / name, action / block: The feature name must match the policy; the callback contains the actual protected work.
Returns: Promise<T>
Return the business callback's result; authorization failures and business exceptions report errors.

Runtime.deactivate

deactivate(signal?: AbortSignal) → Promise<unknown>

Purpose: Perform official SDK device logout; the application separately revokes the Launch account session.
Parameters: ctx / ct / signal / cancellation: Request context or cancellation signal; Go's lifecycle context also controls background work.
Returns: Promise<unknown>
No business return value; normal completion means success, while errors or exceptions report failure.

Runtime.logout

logout?(signal?: AbortSignal) → Promise<{local_complete:boolean,revocation_pending:boolean,storage_error?:string}>

Purpose: Perform official SDK device logout; the application separately revokes the Launch account session.
Parameters: ctx / ct / signal / cancellation: Request context or cancellation signal; Go's lifecycle context also controls background work.
Returns: Promise<{local_complete:boolean,revocation_pending:boolean,storage_error?:string}>
Local logout and remote revocation are distinct. Handle pending or storage failures and preserve the SDK logout journal.

Runtime.close

close() → Promise<unknown>

Purpose: Stop this instance and background tasks while preserving remembered login and device binding.
Returns: Promise<unknown>
No business return value; ordinary close does not confirm account logout or device release.

Rust

Matching source · v0.1.6 · lib.rs · store.rs · transport.rs

Errors and failures: Result<T, Failure>: Ok(value) / Err(Failure {code, status, request_id, retry_after, transport})

Application::connect

Application::connect(origin: &str, product_id: &str, licentivo_product_id: &str, trusted_keys: &[(&str,&str)], environment: &str) → Result<Application, Failure>

Purpose: Validate public settings and create an application; initialization neither signs in nor authorizes protected work.
Parameters: merchantOrigin / origin: The current store origin, including scheme and required port; use HTTPS in production.
productID / product_id: The Launch store product ID, filled automatically by administration integration code.
licentivoProductID / licentivo_product_id: The Licentivo licensing product ID; it must match public signing configuration.
trustedKeys / trusted_keys: A signing-key-ID to public-key map used to verify official SDK signed grants.
environment: sandbox or live; keep accounts, products and caches in the same environment.
Returns: Result<Application, Failure>
Return the created object; initialization alone does not establish authorization.

Application::login

login(&mut self, email: &str, password: &str) → Result<State, Failure>

Purpose: Sign in with a store account, obtain a short-lived identity assertion and start the official authorization SDK.
Parameters: email, password: The customer's email and password at this store; use the password only for this login.
Returns: Result<State, Failure>
Return account state; see the return-field table below.

Application::restore

restore(&mut self) → Result<State, Failure>

Purpose: Read a saved account session, confirm the account online, obtain a fresh assertion and start the official SDK.
Returns: Result<State, Failure>
Return account state; ErrNoSession or NO_SESSION means no saved session. Handle other errors separately.

Application::run_feature

run_feature<T,F: FnOnce() -> Result<T,Failure>>(&mut self, feature: &str, action: F) → Result<T, Failure>

Purpose: The official SDK checks permission on every execution. It runs the callback only when allowed.
Parameters: feature / name, action / block: The feature name must match the policy; the callback contains the actual protected work.
Returns: Result<T, Failure>
Return the business callback's result; authorization failures and business exceptions report errors.

Application::logout

logout(&mut self) → Result<(), Failure>

Purpose: Stop local authorization, sign out through the official SDK, then revoke the Launch session. Retain unfinished remote tasks for retry.
Returns: Result<(), Failure>
No business return value; normal completion means success, while errors or exceptions report failure.

Application::release_device

release_device(&mut self) → Result<(), Failure>

Purpose: Compatibility entry for explicit logout; performs the same account and device logout flow as Logout.
Returns: Result<(), Failure>
No business return value; normal completion means success, while errors or exceptions report failure.

Application::close / Drop

close(&mut self) / drop(&mut self) → ()

Purpose: Stop this instance and background tasks while preserving remembered login and device binding.
Returns: ()
No business return value; ordinary close does not confirm account logout or device release.

Advanced and compatibility APIs

Application::new

Application::new(config: Config, product: Value, cache_root: PathBuf) → Result<Application, Failure>

Purpose: Validate public settings and create an application; initialization neither signs in nor authorizes protected work.
Parameters: config, product: Configuration, runtime adapter, transport or request objects, supplied only for advanced integrations.
cache_root: Caller-selected configuration paths or the current user's private cache or storage directory.
Returns: Result<Application, Failure>
Return the created object; initialization alone does not establish authorization.

Application::with_components

Application::with_components(config: Config, product: Value, cache_root: PathBuf, store: Box<dyn Store>, transport: Box<dyn Transport>, factory: Box<dyn RuntimeFactory>, sleeper: Box<dyn Sleeper>) → Result<Application, Failure>

Purpose: Validate public settings and create an application; initialization neither signs in nor authorizes protected work.
Parameters: config, product: Configuration, runtime adapter, transport or request objects, supplied only for advanced integrations.
cache_root: Caller-selected configuration paths or the current user's private cache or storage directory.
store, transport, factory, sleeper: Optional session storage, private cache directory, cancellation, retries or advanced components.
Returns: Result<Application, Failure>
Return the created object; initialization alone does not establish authorization.

Config::new

Config::new(origin: &str, product: &str, runtime_product: &str, environment: &str) → Result<Config, Failure>

Purpose: Validate or read public settings; product IDs, environment and signing keys must match.
Parameters: merchantOrigin / origin: The current store origin, including scheme and required port; use HTTPS in production.
productID / product_id: The Launch store product ID, filled automatically by administration integration code.
licentivoProductID / licentivo_product_id: The Licentivo licensing product ID; it must match public signing configuration.
environment: sandbox or live; keep accounts, products and caches in the same environment.
Returns: Result<Config, Failure>
Return the value type shown in the signature; the result itself grants no feature permission.

Config::load

Config::load(path: impl AsRef<Path>) → Result<Config, Failure>

Purpose: Validate or read public settings; product IDs, environment and signing keys must match.
Parameters: path: Caller-selected configuration paths or the current user's private cache or storage directory.
Returns: Result<Config, Failure>
Return the value type shown in the signature; the result itself grants no feature permission.

read_public

read_public(path: impl AsRef<Path>) → Result<Value, Failure>

Purpose: Validate or read public settings; product IDs, environment and signing keys must match.
Parameters: path: Caller-selected configuration paths or the current user's private cache or storage directory.
Returns: Result<Value, Failure>
Return the value type shown in the signature; the result itself grants no feature permission.

MemoryStore::default

MemoryStore::default() → MemoryStore

Purpose: Create session storage valid only within this process.
Returns: MemoryStore
Return the created object; initialization alone does not establish authorization.

EncryptedFileStore::new

EncryptedFileStore::new(root: PathBuf, vault_key: [u8;32]) → Result<EncryptedFileStore, Failure>

Purpose: Create protected persistent session storage; obtain its encryption key from the operating system credential vault.
Parameters: root: Caller-selected configuration paths or the current user's private cache or storage directory.
vault_key: An encryption key from the operating system credential vault; never store it beside encrypted records.
Returns: Result<EncryptedFileStore, Failure>
Return the created object; initialization alone does not establish authorization.

CurlTransport::new

CurlTransport::new() → Result<CurlTransport, Failure>

Purpose: Send account HTTP requests and return status, headers or raw body; make no authorization decision.
Returns: Result<CurlTransport, Failure>
Return the created object; initialization alone does not establish authorization.

CurlTransport::request

request(&mut self, method: &str, url: &str, bearer: &str, body: &[u8]) → Result<Response, Failure>

Purpose: Send account HTTP requests and return status, headers or raw body; make no authorization decision.
Parameters: method, url, bearer, body: Configuration, runtime adapter, transport or request objects, supplied only for advanced integrations.
Returns: Result<Response, Failure>
Return the value type shown in the signature; the result itself grants no feature permission.

Failure::new

Failure::new(code: &str) → Failure

Purpose: Create or read structured errors for classification, backoff and troubleshooting correlation.
Parameters: code: Create or read structured errors for classification, backoff and troubleshooting correlation.
Returns: Failure
Return the value type shown in the signature; the result itself grants no feature permission.

ThreadSleeper::sleep

sleep(&mut self, duration: Duration) → Result<(), Failure>

Purpose: Wait for the specified duration for advanced retry scheduling.
Parameters: duration: Suggested retry delay; observe language differences between seconds, milliseconds and Duration.
Returns: Result<(), Failure>
No business return value; normal completion means success, while errors or exceptions report failure.

Store::load / MemoryStore::load / EncryptedFileStore::load

load(&mut self, scope: &str) → Result<Option<Vec<u8>>, Failure>

Purpose: Load an account record by isolated key; it contains secrets and belongs only in the SDK.
Parameters: scope / key, value / record: SDK isolation keys and secret records; custom storage must support multiple keys and atomic replacement.
Returns: Result<Option<Vec<u8>>, Failure>
Return the secret record; absence yields an empty value or ErrNoSession according to the language contract.

Store::save / MemoryStore::save / EncryptedFileStore::save

save(&mut self, scope: &str, value: &[u8]) → Result<(), Failure>

Purpose: Atomically save an account record under its isolated key.
Parameters: scope / key, value / record: SDK isolation keys and secret records; custom storage must support multiple keys and atomic replacement.
Returns: Result<(), Failure>
No business return value; normal completion means success, while errors or exceptions report failure.

Store::delete / MemoryStore::delete / EncryptedFileStore::delete

delete(&mut self, scope: &str) → Result<(), Failure>

Purpose: Delete the account record, preserving official SDK authorization caches and logout journals.
Parameters: scope / key, value / record: SDK isolation keys and secret records; custom storage must support multiple keys and atomic replacement.
Returns: Result<(), Failure>
No business return value; normal completion means success, while errors or exceptions report failure.

Runtime::run_feature

run_feature(&mut self, feature: &str, action: &mut dyn FnMut() -> Result<(),Failure>) → Result<(), Failure>

Purpose: The official SDK checks permission on every execution. It runs the callback only when allowed.
Parameters: feature / name, action / block: The feature name must match the policy; the callback contains the actual protected work.
Returns: Result<(), Failure>
No business return value; normal completion means success, while errors or exceptions report failure.

Runtime::release_device

release_device(&mut self) → Result<(), Failure>

Purpose: Perform official SDK device logout; the application separately revokes the Launch account session.
Returns: Result<(), Failure>
No business return value; normal completion means success, while errors or exceptions report failure.

Runtime::close

close(&mut self) → ()

Purpose: Stop this instance and background tasks while preserving remembered login and device binding.
Returns: ()
No business return value; ordinary close does not confirm account logout or device release.

RuntimeFactory::open / OfficialRuntimeFactory::open

open(&mut self, settings: &Value, cached_only: bool) → Result<Box<dyn Runtime>, Failure>

Purpose: Create an official SDK adapter for advanced integrations; pass the identity assertion only in memory.
Parameters: settings, cached_only: Configuration, runtime adapter, transport or request objects, supplied only for advanced integrations.
Returns: Result<Box<dyn Runtime>, Failure>
Return the created object; initialization alone does not establish authorization.

RuntimeFactory::for_logout / OfficialRuntimeFactory::for_logout

for_logout(&mut self, settings: &Value) → Result<Box<dyn Runtime>, Failure>

Purpose: Create an official SDK adapter for advanced integrations; pass the identity assertion only in memory.
Parameters: settings: Configuration, runtime adapter, transport or request objects, supplied only for advanced integrations.
Returns: Result<Box<dyn Runtime>, Failure>
Return the created object; initialization alone does not establish authorization.

Sleeper::sleep

sleep(&mut self, duration: Duration) → Result<(), Failure>

Purpose: Wait for the specified duration for advanced retry scheduling.
Parameters: duration: Suggested retry delay; observe language differences between seconds, milliseconds and Duration.
Returns: Result<(), Failure>
No business return value; normal completion means success, while errors or exceptions report failure.

Ruby

Matching source · v0.1.6 · licentivo_launch.rb

Errors and failures: rescue LicentivoLaunch::Error; code / status / retry_after_seconds; callback exceptions

Application.connect

LicentivoLaunch::Application.connect(merchant_origin, product_id, licentivo_product_id, trusted_keys, environment: "live", **options) → Application

Purpose: Validate public settings and create an application; initialization neither signs in nor authorizes protected work.
Parameters: merchantOrigin / origin: The current store origin, including scheme and required port; use HTTPS in production.
productID / product_id: The Launch store product ID, filled automatically by administration integration code.
licentivoProductID / licentivo_product_id: The Licentivo licensing product ID; it must match public signing configuration.
trustedKeys / trusted_keys: A signing-key-ID to public-key map used to verify official SDK signed grants.
environment: sandbox or live; keep accounts, products and caches in the same environment.
options / config: Optional session storage, private cache directory, cancellation, retries or advanced components.
Returns: Application
Return the created object; initialization alone does not establish authorization.

Application#login

login(email, password, cancellation: nil) → Hash

Purpose: Sign in with a store account, obtain a short-lived identity assertion and start the official authorization SDK.
Parameters: email, password: The customer's email and password at this store; use the password only for this login.
ctx / ct / signal / cancellation: Request context or cancellation signal; Go's lifecycle context also controls background work.
Returns: Hash
Return account state; see the return-field table below.

Application#restore

restore(cancellation: nil) → Hash | nil

Purpose: Read a saved account session, confirm the account online, obtain a fresh assertion and start the official SDK.
Parameters: ctx / ct / signal / cancellation: Request context or cancellation signal; Go's lifecycle context also controls background work.
Returns: Hash | nil
Return account state; null or nil means no restorable session. Other failures report errors.

Application#run_feature

run_feature(feature) { ... } → T

Purpose: The official SDK checks permission on every execution. It runs the callback only when allowed.
Parameters: feature / name, action / block: The feature name must match the policy; the callback contains the actual protected work.
Returns: T
Return the business callback's result; authorization failures and business exceptions report errors.

Application#logout

logout(cancellation: nil) → true | false

Purpose: Stop local authorization, sign out through the official SDK, then revoke the Launch session. Retain unfinished remote tasks for retry.
Parameters: ctx / ct / signal / cancellation: Request context or cancellation signal; Go's lifecycle context also controls background work.
Returns: true | false
true confirms logout; false means remote account logout or device revocation is pending. Storage failures may still raise errors.

Application#release_device

release_device(cancellation: nil) → true | false

Purpose: Compatibility entry for explicit logout; performs the same account and device logout flow as Logout.
Parameters: ctx / ct / signal / cancellation: Request context or cancellation signal; Go's lifecycle context also controls background work.
Returns: true | false
true confirms logout; false means remote account logout or device revocation is pending. Storage failures may still raise errors.

Application#close

close → nil

Purpose: Stop this instance and background tasks while preserving remembered login and device binding.
Returns: nil
No business return value; ordinary close does not confirm account logout or device release.

Advanced and compatibility APIs

Application.new

Application.new(launch, product, store: MemoryStore.new, transport: nil, runtime_factory: nil, cache_dir: nil, sleep: nil, pending_attempts: 5) → Application

Purpose: Validate public settings and create an application; initialization neither signs in nor authorizes protected work.
Parameters: launch, product: Configuration, runtime adapter, transport or request objects, supplied only for advanced integrations.
options / config: Optional session storage, private cache directory, cancellation, retries or advanced components.
Returns: Application
Return the created object; initialization alone does not establish authorization.

Application.from_files

Application.from_files(launch_path, product_path, **options) → Application

Purpose: Read two existing public configuration files, validate their product mapping and create an application. Direct connection needs no files.
Parameters: launchPath, productPath: Caller-selected configuration paths or the current user's private cache or storage directory.
options / config: Optional session storage, private cache directory, cancellation, retries or advanced components.
Returns: Application
Return the created object; initialization alone does not establish authorization.

LicentivoLaunch.origin

LicentivoLaunch.origin(value, environment) → String

Purpose: Validate or read public settings; product IDs, environment and signing keys must match.
Parameters: value: The current store origin, including scheme and required port; use HTTPS in production.
environment: sandbox or live; keep accounts, products and caches in the same environment.
Returns: String
Return the value type shown in the signature; the result itself grants no feature permission.

LicentivoLaunch.validate_config

LicentivoLaunch.validate_config(launch, product) → [Hash, Hash]

Purpose: Validate or read public settings; product IDs, environment and signing keys must match.
Parameters: launch, product: Configuration, runtime adapter, transport or request objects, supplied only for advanced integrations.
Returns: [Hash, Hash]
Return the value type shown in the signature; the result itself grants no feature permission.

LicentivoLaunch.load_config

LicentivoLaunch.load_config(launch_path, product_path) → [Hash, Hash]

Purpose: Validate or read public settings; product IDs, environment and signing keys must match.
Parameters: launchPath, productPath: Caller-selected configuration paths or the current user's private cache or storage directory.
Returns: [Hash, Hash]
Return the value type shown in the signature; the result itself grants no feature permission.

LicentivoLaunch.default_transport

LicentivoLaunch.default_transport(request) → Hash

Purpose: Send account HTTP requests and return status, headers or raw body; make no authorization decision.
Parameters: request: Configuration, runtime adapter, transport or request objects, supplied only for advanced integrations.
Returns: Hash
Return the value type shown in the signature; the result itself grants no feature permission.

MemoryStore.new

MemoryStore.new → MemoryStore

Purpose: Create session storage valid only within this process.
Returns: MemoryStore
Return the created object; initialization alone does not establish authorization.

EncryptedFileStore.new

EncryptedFileStore.new(directory, key) → EncryptedFileStore

Purpose: Create protected persistent session storage; obtain its encryption key from the operating system credential vault.
Parameters: directory: Caller-selected configuration paths or the current user's private cache or storage directory.
key: An encryption key from the operating system credential vault; never store it beside encrypted records.
Returns: EncryptedFileStore
Return the created object; initialization alone does not establish authorization.

MemoryStore#persistent? / EncryptedFileStore#persistent? / #secure?

persistent? / secure? → true | false

Purpose: Validate or read public settings; product IDs, environment and signing keys must match.
Returns: true | false
Return a Boolean classification, not an authorization grant.

EncryptedFileStore#path

path(scope) → String

Purpose: Validate or read public settings; product IDs, environment and signing keys must match.
Parameters: scope: SDK isolation keys and secret records; custom storage must support multiple keys and atomic replacement.
Returns: String
Return the value type shown in the signature; the result itself grants no feature permission.

CancellationToken#cancel / #check!

CancellationToken.new.cancel / check! → true / nil

Purpose: Request or check cooperative cancellation; cancellation does not mean authorization succeeded.
Returns: true / nil
No business return value; normal completion means success, while errors or exceptions report failure.

Error.new

Error.new(code, status: 0, retry_after_seconds: 0) → Error

Purpose: Create or read structured errors for classification, backoff and troubleshooting correlation.
Parameters: code, status, retry_after_seconds: Create or read structured errors for classification, backoff and troubleshooting correlation.
Returns: Error
Return the value type shown in the signature; the result itself grants no feature permission.

MemoryStore#load / EncryptedFileStore#load

load(scope) → Hash | nil

Purpose: Load an account record by isolated key; it contains secrets and belongs only in the SDK.
Parameters: scope / key, value / record: SDK isolation keys and secret records; custom storage must support multiple keys and atomic replacement.
Returns: Hash | nil
Return the secret record; absence yields an empty value or ErrNoSession according to the language contract.

MemoryStore#save / EncryptedFileStore#save

save(scope, record) → Object

Purpose: Atomically save an account record under its isolated key.
Parameters: scope / key, value / record: SDK isolation keys and secret records; custom storage must support multiple keys and atomic replacement.
Returns: Object
No business return value; normal completion means success, while errors or exceptions report failure.

MemoryStore#delete / EncryptedFileStore#delete

delete(scope) → Object

Purpose: Delete the account record, preserving official SDK authorization caches and logout journals.
Parameters: scope / key, value / record: SDK isolation keys and secret records; custom storage must support multiple keys and atomic replacement.
Returns: Object
No business return value; normal completion means success, while errors or exceptions report failure.

Matching source · v0.1.6 · account.h · account.c

Errors and failures: NULL / 0 / -1; launch_application_error(app); action(context): 1=success, 0=failure

launch_application_connect

launch_application_connect(origin, product_id, licentivo_product_id, trusted_keys_json, environment, remember, store) → launch_application *

Purpose: Validate public settings and create an application; initialization neither signs in nor authorizes protected work.
Parameters: merchantOrigin / origin: The current store origin, including scheme and required port; use HTTPS in production.
productID / product_id: The Launch store product ID, filled automatically by administration integration code.
licentivoProductID / licentivo_product_id: The Licentivo licensing product ID; it must match public signing configuration.
trustedKeys / trusted_keys: A signing-key-ID to public-key map used to verify official SDK signed grants.
environment: sandbox or live; keep accounts, products and caches in the same environment.
remember, store: Optional session storage, private cache directory, cancellation, retries or advanced components.
Returns: launch_application *
Return an owned application pointer; NULL means initialization failed. Release it with close.

launch_application_login

launch_application_login(launch_application *app, const char *email, const char *password) → int

Purpose: Sign in with a store account, obtain a short-lived identity assertion and start the official authorization SDK.
Parameters: email, password: The customer's email and password at this store; use the password only for this login.
Returns: int
1 means success; 0 means failure. Read the error code after failure.

launch_application_restore

launch_application_restore(launch_application *app) → int

Purpose: Read a saved account session, confirm the account online, obtain a fresh assertion and start the official SDK.
Returns: int
1 means restored, 0 means no session, -1 means denied or failed. Read the error code after failure.

launch_application_run_feature

launch_application_run_feature(app, feature, ln_feature_action action, void *context) → int

Purpose: The official SDK checks permission on every execution. It runs the callback only when allowed.
Parameters: feature / name, action / block: The feature name must match the policy; the callback contains the actual protected work.
context: Configuration, runtime adapter, transport or request objects, supplied only for advanced integrations.
Returns: int
1 means success; 0 means failure. Read the error code after failure.

launch_application_logout

launch_application_logout(launch_application *app) → int

Purpose: Stop local authorization, sign out through the official SDK, then revoke the Launch session. Retain unfinished remote tasks for retry.
Returns: int
1 means success; 0 means failure. Read the error code after failure.

launch_application_release_device

launch_application_release_device(launch_application *app) → int

Purpose: Compatibility entry for explicit logout; performs the same account and device logout flow as Logout.
Returns: int
1 means success; 0 means failure. Read the error code after failure.

launch_application_status

launch_application_status(launch_application *app) → char *

Purpose: Read current official SDK authorization status. This neither signs in nor replaces permission checks around protected work.
Returns: char *
Return owned JSON text; release it with ln_free_string. Without a runtime, return login_required and allowed=false.

launch_application_error

launch_application_error(const launch_application *app) → const char *

Purpose: Create or read structured errors for classification, backoff and troubleshooting correlation.
Returns: const char *
Return a borrowed error-code string. Do not free it or access it after application destruction.

launch_application_close

launch_application_close(launch_application *app) → void

Purpose: Stop this instance and background tasks while preserving remembered login and device binding.
Returns: void
No business return value; ordinary close does not confirm account logout or device release.

Advanced and compatibility APIs

launch_application_open

launch_application_open(origin, product_id, product_config_path, environment, remember, store) → launch_application *

Purpose: Read two existing public configuration files, validate their product mapping and create an application. Direct connection needs no files.
Parameters: origin: The current store origin, including scheme and required port; use HTTPS in production.
product_id: The Launch store product ID, filled automatically by administration integration code.
product_config_path: Caller-selected configuration paths or the current user's private cache or storage directory.
environment: sandbox or live; keep accounts, products and caches in the same environment.
remember, store: Optional session storage, private cache directory, cancellation, retries or advanced components.
Returns: launch_application *
Return an owned application pointer; NULL means initialization failed. Release it with close.

launch_application_from_files

launch_application_from_files(launch_config_path, product_config_path, remember, store) → launch_application *

Purpose: Read two existing public configuration files, validate their product mapping and create an application. Direct connection needs no files.
Parameters: launchPath, productPath: Caller-selected configuration paths or the current user's private cache or storage directory.
remember, store: Optional session storage, private cache directory, cancellation, retries or advanced components.
Returns: launch_application *
Return an owned application pointer; NULL means initialization failed. Release it with close.

launch_application_cli

launch_application_cli(int argc, char **argv) → launch_application *

Purpose: Read two existing public configuration files, validate their product mapping and create an application. Direct connection needs no files.
Parameters: argc, argv: Configuration, runtime adapter, transport or request objects, supplied only for advanced integrations.
Returns: launch_application *
Return an owned application pointer; NULL means initialization failed. Release it with close.

launch_login / launch_sign_in

launch_login(account, origin, product_id, config_path, environment, email, password) / launch_sign_in(account, argc, argv) → int

Purpose: Retained legacy API; the long-term license credential protocol was removed, so calls fail. Use Application for new integrations.
Parameters: account, origin, product_id, config_path, environment, email, password, argc, argv: Configuration, runtime adapter, transport or request objects, supplied only for advanced integrations.
Returns: int
Always fails; migrate to account identity exchange.

launch_sign_out

launch_sign_out(launch_account *account, int clear_cache) → void

Purpose: Stop this instance and background tasks while preserving remembered login and device binding.
Parameters: account, clear_cache: Configuration, runtime adapter, transport or request objects, supplied only for advanced integrations.
Returns: void
No business return value; normal completion means success, while errors or exceptions report failure.

ln_free_string

ln_free_string(char *value) → void

Purpose: Stop this instance and background tasks while preserving remembered login and device binding.
Parameters: value: Return owned JSON text; release it with ln_free_string. Without a runtime, return login_required and allowed=false.
Returns: void
No business return value; normal completion means success, while errors or exceptions report failure.

launch_secret_store.load

load(void *context, const char *scope, char **record) → int

Purpose: Load an account record by isolated key; it contains secrets and belongs only in the SDK.
Parameters: context: Configuration, runtime adapter, transport or request objects, supplied only for advanced integrations.
scope, record: SDK isolation keys and secret records; custom storage must support multiple keys and atomic replacement.
Returns: int
1 means found, 0 absent, -1 read failure. load must allocate record; the caller frees it.

launch_secret_store.save

save(void *context, const char *scope, const char *record) → int (1: success, 0: failure)

Purpose: Atomically save an account record under its isolated key.
Parameters: context: Configuration, runtime adapter, transport or request objects, supplied only for advanced integrations.
scope, record: SDK isolation keys and secret records; custom storage must support multiple keys and atomic replacement.
Returns: int (1: success, 0: failure)
No business return value; normal completion means success, while errors or exceptions report failure.

launch_secret_store.remove

remove(void *context, const char *scope) → int (1: success, 0: failure)

Purpose: Delete the account record, preserving official SDK authorization caches and logout journals.
Parameters: context: Configuration, runtime adapter, transport or request objects, supplied only for advanced integrations.
scope: SDK isolation keys and secret records; custom storage must support multiple keys and atomic replacement.
Returns: int (1: success, 0: failure)
No business return value; normal completion means success, while errors or exceptions report failure.

C++

Matching source · v0.1.6 · launch.hpp

Errors and failures: std::runtime_error; callback exceptions propagate; RAII; Status(): std::string JSON

Application::Connect

Application::Connect(origin, product, licentivo_product, trusted_keys_json, environment="live", remember=false, store=nullptr) → Application

Purpose: Validate public settings and create an application; initialization neither signs in nor authorizes protected work.
Parameters: merchantOrigin / origin: The current store origin, including scheme and required port; use HTTPS in production.
productID / product_id: The Launch store product ID, filled automatically by administration integration code.
licentivoProductID / licentivo_product_id: The Licentivo licensing product ID; it must match public signing configuration.
trustedKeys / trusted_keys: A signing-key-ID to public-key map used to verify official SDK signed grants.
environment: sandbox or live; keep accounts, products and caches in the same environment.
remember, store: Optional session storage, private cache directory, cancellation, retries or advanced components.
Returns: Application
Return the created object; initialization alone does not establish authorization.

Application::Login

Login(const char *email, const char *password) → void

Purpose: Sign in with a store account, obtain a short-lived identity assertion and start the official authorization SDK.
Parameters: email, password: The customer's email and password at this store; use the password only for this login.
Returns: void
No business return value; normal completion means success, while errors or exceptions report failure.

Application::Restore

Restore() → bool

Purpose: Read a saved account session, confirm the account online, obtain a fresh assertion and start the official SDK.
Returns: bool
true means restored; false means no restorable session. Denial, expiry and network failures report errors.

Application::RunFeature

RunFeature(const char *feature, Action action) → void

Purpose: The official SDK checks permission on every execution. It runs the callback only when allowed.
Parameters: feature / name, action / block: The feature name must match the policy; the callback contains the actual protected work.
Returns: void
No business return value; normal completion means success, while errors or exceptions report failure.

Application::Logout

Logout() → void

Purpose: Stop local authorization, sign out through the official SDK, then revoke the Launch session. Retain unfinished remote tasks for retry.
Returns: void
No business return value; normal completion means success, while errors or exceptions report failure.

Application::ReleaseDevice

ReleaseDevice() → void

Purpose: Compatibility entry for explicit logout; performs the same account and device logout flow as Logout.
Returns: void
No business return value; normal completion means success, while errors or exceptions report failure.

Application::Status

Status() → std::string (JSON)

Purpose: Read current official SDK authorization status. This neither signs in nor replaces permission checks around protected work.
Returns: std::string (JSON)
Read current official SDK authorization status. This neither signs in nor replaces permission checks around protected work.

Application::~Application

~Application() → void

Purpose: Stop this instance and background tasks while preserving remembered login and device binding.
Returns: void
No business return value; ordinary close does not confirm account logout or device release.

Advanced and compatibility APIs

Application

Application(origin, product, config, environment="live", remember=false, store=nullptr) → Application

Purpose: Read two existing public configuration files, validate their product mapping and create an application. Direct connection needs no files.
Parameters: origin: The current store origin, including scheme and required port; use HTTPS in production.
product: The Launch store product ID, filled automatically by administration integration code.
config: Caller-selected configuration paths or the current user's private cache or storage directory.
environment: sandbox or live; keep accounts, products and caches in the same environment.
remember, store: Optional session storage, private cache directory, cancellation, retries or advanced components.
Returns: Application
Return the created object; initialization alone does not establish authorization.

Application(launch_application *)

explicit Application(launch_application *app) → Application

Purpose: Validate public settings and create an application; initialization neither signs in nor authorizes protected work.
Parameters: app: Return an owned application pointer; NULL means initialization failed. Release it with close.
Returns: Application
Return the created object; initialization alone does not establish authorization.

Application::FromFiles

Application::FromFiles(launch, product, remember=false, store=nullptr) → Application

Purpose: Read two existing public configuration files, validate their product mapping and create an application. Direct connection needs no files.
Parameters: launch, product: Caller-selected configuration paths or the current user's private cache or storage directory.
remember, store: Optional session storage, private cache directory, cancellation, retries or advanced components.
Returns: Application
Return the created object; initialization alone does not establish authorization.

Application(Application&&) / operator=

Application(Application&& other) / operator=(Application&& other) → Application / Application&

Purpose: Transfer native application ownership. Copying is disabled; the original object no longer owns the pointer.
Parameters: other: Configuration, runtime adapter, transport or request objects, supplied only for advanced integrations.
Returns: Application / Application&
Return the created object; initialization alone does not establish authorization.

Return fields

Return account state; see the return-field table below.

Field	Type	Purpose
`Go State.User.ID · JS user.id · Java userID · Rust user_id · Ruby user.id`	`string`	Unique store account ID; not a product, license or device ID.
`Go User.Email · JS user.email · Java/Rust/Ruby email`	`string`	Store account email; some language states include only the account ID.
`Go User.Verified / user.verified`	`boolean`	Whether the store email is verified; this is not software authorization.
`JS user.display_name`	`string (optional)`	Store account display name; omitted when the server does not supply it.
`Go State/Session.ExpiresAt · JS expiresAt · Java expiresAt · Rust/Ruby expires_at`	`time.Time / ISO 8601 / Instant`	Launch account session expiry; not purchase expiry or an offline authorization deadline.
`Java offlineFallback · Rust offline_fallback`	`boolean = false`	Compatibility field; current account restoration never selects offline fallback, so this is false.
`C / C++ status.allowed · C# Status().Allowed`	`boolean`	Whether the official SDK currently allows use; guard individual features separately.
`C / C++ status.state · C# Status().State`	`string`	Official SDK state name; login_required may appear before login.
`C / C++ status.code · C# Status().Code`	`string`	Stable machine-readable error code used for messages and handling branches.
`C / C++ status.request_id · C# Status().RequestID`	`string`	Server request correlation ID for troubleshooting; not exposed by every language.
`C / C++ status.retryable · C# Status().Retryable`	`boolean`	Whether retry is suggested; this does not permit protected work now.
`C / C++ status.lease_valid_until · C# Status().LeaseValidUntil`	`Unix seconds`	Official SDK signed-grant expiry in Unix seconds; distinct from account session expiry.
`Go Identity.ProductID / product_id`	`UUID`	The Launch store product ID, filled automatically by administration integration code.
`Go Identity.LicentivoProductID / licentivo_product_id`	`UUID`	The Licentivo licensing product ID; it must match public signing configuration.
`Go Identity.LaunchConnectionID / launch_connection_id`	`UUID`	Pinned Launch licensing connection ID; it must match the product and environment.
`Go Identity.Environment / environment`	`sandbox \| live`	sandbox or live; keep accounts, products and caches in the same environment.
`Go Identity.IdentityToken / identity_token`	`string`	A short-lived, one-use identity assertion, passed to the official SDK in memory; never an offline credential.
`Go Identity.ExpiresAt / identity.expires_at`	`time.Time / ISO 8601`	Identity assertion expiry; not the account session or purchase expiry.
`Go Session.AccessToken / access_token / token`	`string`	Launch account session token, returned only by low-level session or encrypted-storage interfaces.

Session tokens, assertions and stored records are secret. Keep them out of logs and browser renderers.

Errors and failures

Field	Type	Purpose
`Go APIError.Code · Python APIError.code · C# Code · Java/Rust/Ruby code · JS code · C error()`	`string`	Stable machine-readable error code used for messages and handling branches.
`Go APIError.Status · Python status · C# Status · Java/Rust/Ruby/JS status`	`integer`	HTTP status; 0 means no HTTP response is available.
`Go RequestID · Java requestID · Rust request_id`	`string`	Server request correlation ID for troubleshooting; not exposed by every language.
`Go RetryAfter · Python retry_after · C# RetryAfterSeconds · Java retryAfterMillis · JS/Ruby retryAfterSeconds / retry_after_seconds · Rust retry_after`	`Duration / s / ms`	Suggested retry delay; observe language differences between seconds, milliseconds and Duration.

Local logout and remote revocation are distinct. Handle pending or storage failures and preserve the SDK logout journal.