@engini/client 0.0.0 → 0.3.0

package/dist/index.d.ts

@@ -0,0 +1,3026 @@
+type AuthToken = string | undefined;
+interface Auth {
+    /**
+     * Which part of the request do we use to send the auth?
+     *
+     * @default 'header'
+     */
+    in?: 'header' | 'query' | 'cookie';
+    /**
+     * A unique identifier for the security scheme.
+     *
+     * Defined only when there are multiple security schemes whose `Auth`
+     * shape would otherwise be identical.
+     */
+    key?: string;
+    /**
+     * Header or query parameter name.
+     *
+     * @default 'Authorization'
+     */
+    name?: string;
+    scheme?: 'basic' | 'bearer';
+    type: 'apiKey' | 'http';
+}
+
+interface SerializerOptions<T> {
+    /**
+     * @default true
+     */
+    explode: boolean;
+    style: T;
+}
+type ArrayStyle = 'form' | 'spaceDelimited' | 'pipeDelimited';
+type ObjectStyle = 'form' | 'deepObject';
+
+type QuerySerializer = (query: Record<string, unknown>) => string;
+type BodySerializer = (body: unknown) => unknown;
+type QuerySerializerOptionsObject = {
+    allowReserved?: boolean;
+    array?: Partial<SerializerOptions<ArrayStyle>>;
+    object?: Partial<SerializerOptions<ObjectStyle>>;
+};
+type QuerySerializerOptions = QuerySerializerOptionsObject & {
+    /**
+     * Per-parameter serialization overrides. When provided, these settings
+     * override the global array/object settings for specific parameter names.
+     */
+    parameters?: Record<string, QuerySerializerOptionsObject>;
+};
+
+type HttpMethod = 'connect' | 'delete' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
+type Client$1<RequestFn = never, Config = unknown, MethodFn = never, BuildUrlFn = never, SseFn = never> = {
+    /**
+     * Returns the final request URL.
+     */
+    buildUrl: BuildUrlFn;
+    getConfig: () => Config;
+    request: RequestFn;
+    setConfig: (config: Config) => Config;
+} & {
+    [K in HttpMethod]: MethodFn;
+} & ([SseFn] extends [never] ? {
+    sse?: never;
+} : {
+    sse: {
+        [K in HttpMethod]: SseFn;
+    };
+});
+interface Config$1 {
+    /**
+     * Auth token or a function returning auth token. The resolved value will be
+     * added to the request payload as defined by its `security` array.
+     */
+    auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken;
+    /**
+     * A function for serializing request body parameter. By default,
+     * {@link JSON.stringify()} will be used.
+     */
+    bodySerializer?: BodySerializer | null;
+    /**
+     * An object containing any HTTP headers that you want to pre-populate your
+     * `Headers` object with.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
+     */
+    headers?: RequestInit['headers'] | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined | unknown>;
+    /**
+     * The request method.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
+     */
+    method?: Uppercase<HttpMethod>;
+    /**
+     * A function for serializing request query parameters. By default, arrays
+     * will be exploded in form style, objects will be exploded in deepObject
+     * style, and reserved characters are percent-encoded.
+     *
+     * This method will have no effect if the native `paramsSerializer()` Axios
+     * API function is used.
+     *
+     * {@link https://swagger.io/docs/specification/serialization/#query View examples}
+     */
+    querySerializer?: QuerySerializer | QuerySerializerOptions;
+    /**
+     * A function validating request data. This is useful if you want to ensure
+     * the request conforms to the desired shape, so it can be safely sent to
+     * the server.
+     */
+    requestValidator?: (data: unknown) => Promise<unknown>;
+    /**
+     * A function transforming response data before it's returned. This is useful
+     * for post-processing data, e.g., converting ISO strings into Date objects.
+     */
+    responseTransformer?: (data: unknown) => Promise<unknown>;
+    /**
+     * A function validating response data. This is useful if you want to ensure
+     * the response conforms to the desired shape, so it can be safely passed to
+     * the transformers and returned to the user.
+     */
+    responseValidator?: (data: unknown) => Promise<unknown>;
+}
+
+type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, 'method'> & Pick<Config$1, 'method' | 'responseTransformer' | 'responseValidator'> & {
+    /**
+     * Fetch API implementation. You can use this option to provide a custom
+     * fetch instance.
+     *
+     * @default globalThis.fetch
+     */
+    fetch?: typeof fetch;
+    /**
+     * Implementing clients can call request interceptors inside this hook.
+     */
+    onRequest?: (url: string, init: RequestInit) => Promise<Request>;
+    /**
+     * Callback invoked when a network or parsing error occurs during streaming.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @param error The error that occurred.
+     */
+    onSseError?: (error: unknown) => void;
+    /**
+     * Callback invoked when an event is streamed from the server.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @param event Event streamed from the server.
+     * @returns Nothing (void).
+     */
+    onSseEvent?: (event: StreamEvent<TData>) => void;
+    serializedBody?: RequestInit['body'];
+    /**
+     * Default retry delay in milliseconds.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @default 3000
+     */
+    sseDefaultRetryDelay?: number;
+    /**
+     * Maximum number of retry attempts before giving up.
+     */
+    sseMaxRetryAttempts?: number;
+    /**
+     * Maximum retry delay in milliseconds.
+     *
+     * Applies only when exponential backoff is used.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @default 30000
+     */
+    sseMaxRetryDelay?: number;
+    /**
+     * Optional sleep function for retry backoff.
+     *
+     * Defaults to using `setTimeout`.
+     */
+    sseSleepFn?: (ms: number) => Promise<void>;
+    url: string;
+};
+interface StreamEvent<TData = unknown> {
+    data: TData;
+    event?: string;
+    id?: string;
+    retry?: number;
+}
+type ServerSentEventsResult<TData = unknown, TReturn = void, TNext = unknown> = {
+    stream: AsyncGenerator<TData extends Record<string, unknown> ? TData[keyof TData] : TData, TReturn, TNext>;
+};
+
+type ErrInterceptor<Err, Res, Req, Options> = (error: Err, 
+/** response may be undefined due to a network error where no response object is produced */
+response: Res | undefined, 
+/** request may be undefined, because error may be from building the request object itself */
+request: Req | undefined, options: Options) => Err | Promise<Err>;
+type ReqInterceptor<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>;
+type ResInterceptor<Res, Req, Options> = (response: Res, request: Req, options: Options) => Res | Promise<Res>;
+declare class Interceptors<Interceptor> {
+    fns: Array<Interceptor | null>;
+    clear(): void;
+    eject(id: number | Interceptor): void;
+    exists(id: number | Interceptor): boolean;
+    getInterceptorIndex(id: number | Interceptor): number;
+    update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false;
+    use(fn: Interceptor): number;
+}
+interface Middleware<Req, Res, Err, Options> {
+    error: Interceptors<ErrInterceptor<Err, Res, Req, Options>>;
+    request: Interceptors<ReqInterceptor<Req, Options>>;
+    response: Interceptors<ResInterceptor<Res, Req, Options>>;
+}
+
+type ResponseStyle = 'data' | 'fields';
+interface Config<T extends ClientOptions$1 = ClientOptions$1> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config$1 {
+    /**
+     * Base URL for all requests made by this client.
+     */
+    baseUrl?: T['baseUrl'];
+    /**
+     * Fetch API implementation. You can use this option to provide a custom
+     * fetch instance.
+     *
+     * @default globalThis.fetch
+     */
+    fetch?: typeof fetch;
+    /**
+     * Please don't use the Fetch client for Next.js applications. The `next`
+     * options won't have any effect.
+     *
+     * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
+     */
+    next?: never;
+    /**
+     * Return the response data parsed in a specified format. By default, `auto`
+     * will infer the appropriate method from the `Content-Type` response header.
+     * You can override this behavior with any of the {@link Body} methods.
+     * Select `stream` if you don't want to parse response data at all.
+     *
+     * @default 'auto'
+     */
+    parseAs?: 'arrayBuffer' | 'auto' | 'blob' | 'formData' | 'json' | 'stream' | 'text';
+    /**
+     * Should we return only data or multiple fields (data, error, response, etc.)?
+     *
+     * @default 'fields'
+     */
+    responseStyle?: ResponseStyle;
+    /**
+     * Throw an error instead of returning it in the response?
+     *
+     * @default false
+     */
+    throwOnError?: T['throwOnError'];
+}
+interface RequestOptions<TData = unknown, TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends Config<{
+    responseStyle: TResponseStyle;
+    throwOnError: ThrowOnError;
+}>, Pick<ServerSentEventsOptions<TData>, 'onRequest' | 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
+    /**
+     * Any body that you want to add to your request.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
+     */
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    /**
+     * Security mechanism(s) to use for the request.
+     */
+    security?: ReadonlyArray<Auth>;
+    url: Url;
+}
+interface ResolvedRequestOptions<TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
+    headers: Headers;
+    serializedBody?: string;
+}
+type RequestResult<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = 'fields'> = ThrowOnError extends true ? Promise<TResponseStyle extends 'data' ? TData extends Record<string, unknown> ? TData[keyof TData] : TData : {
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    request: Request;
+    response: Response;
+}> : Promise<TResponseStyle extends 'data' ? (TData extends Record<string, unknown> ? TData[keyof TData] : TData) | undefined : ({
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    error: undefined;
+} | {
+    data: undefined;
+    error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
+}) & {
+    /** request may be undefined, because error may be from building the request object itself */
+    request?: Request;
+    /** response may be undefined, because error may be from building the request object itself or from a network error */
+    response?: Response;
+}>;
+interface ClientOptions$1 {
+    baseUrl?: string;
+    responseStyle?: ResponseStyle;
+    throwOnError?: boolean;
+}
+type MethodFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type SseFn = <TData = unknown, _TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<never, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData>>;
+type RequestFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'> & Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type BuildUrlFn = <TData extends {
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    url: string;
+}>(options: TData & Options$1<TData>) => string;
+type Client = Client$1<RequestFn, Config, MethodFn, BuildUrlFn, SseFn> & {
+    interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
+};
+interface TDataShape {
+    body?: unknown;
+    headers?: unknown;
+    path?: unknown;
+    query?: unknown;
+    url: string;
+}
+type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
+type Options$1<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle = 'fields'> = OmitKeys<RequestOptions<TResponse, TResponseStyle, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & ([TData] extends [never] ? unknown : Omit<TData, 'url'>);
+
+type ClientOptions = {
+    baseUrl: 'https://feat-public-api.staging.engini.io/api' | (string & {});
+};
+type SolutionAdminWriteResponse = {
+    solution: SolutionDetailResponse;
+    warnings: Array<string>;
+};
+type SolutionDetailResponse = {
+    solutionId: number;
+    slug: string;
+    name: string;
+    description?: string | null;
+    iconUrl?: string | null;
+    status: string;
+    manifestVersion: number;
+    installCount: number;
+    createdDate: string;
+    updatedDate?: string | null;
+    manifest: string;
+};
+type ErrorResponse = {
+    errorCode: string;
+    message: string;
+    requestId: string;
+    timestamp: string;
+    path: string;
+    details?: Array<ErrorDetail> | null;
+};
+type ErrorDetail = {
+    field: string;
+    issue: string;
+};
+type CreateSolutionRequest = {
+    slug: string;
+    name: string;
+    description?: string | null;
+    iconUrl?: string | null;
+    buildManifest: SolutionManifestBuildSpec;
+};
+type SolutionManifestBuildSpec = {
+    workflows: Array<BuildManifestWorkflow>;
+    tables: Array<BuildManifestTable>;
+    connections: Array<ManifestConnection>;
+    version?: string | null;
+};
+type BuildManifestWorkflow = {
+    workflowId: number;
+    key: string;
+    name?: string | null;
+    isWebhookEntrypoint: boolean;
+};
+type BuildManifestTable = {
+    tableId: string;
+    key: string;
+};
+type ManifestConnection = {
+    key: string;
+    applicationId: number;
+    label?: string | null;
+    required: boolean;
+    requiresUserToken: boolean;
+    defaultConfig?: ManifestConnectionDefaults | null;
+};
+type ManifestConnectionDefaults = {
+    baseUrl?: string | null;
+};
+type UpdateSolutionRequest = {
+    name?: string | null;
+    description?: string | null;
+    iconUrl?: string | null;
+    buildManifest?: SolutionManifestBuildSpec | null;
+};
+type BuildManifestResponse = {
+    manifest: SolutionManifest;
+    warnings: Array<string>;
+    solution?: SolutionDetailResponse | null;
+};
+type SolutionManifest = {
+    version: string;
+    connections?: Array<ManifestConnection> | null;
+    tables?: Array<ManifestTable> | null;
+    workflows?: Array<ManifestWorkflow> | null;
+};
+type ManifestTable = {
+    key: string;
+    definition: TableDefinitionDto;
+};
+type TableDefinitionDto = {
+    name: string;
+    description?: string | null;
+    fields: Array<TableFieldDto>;
+};
+type TableFieldDto = {
+    fieldName: string;
+    fieldTypeId: number;
+    displayName?: string | null;
+    defaultValue?: string | null;
+    fieldOrder: number;
+    isPrimaryKey: boolean;
+    isMandatory: boolean;
+    isHidden: boolean;
+    isMultiSelect: boolean;
+    picklistJson?: string | null;
+    databaseFieldName?: string | null;
+    databaseFieldLocationTable?: string | null;
+};
+type ManifestWorkflow = {
+    key: string;
+    name?: string | null;
+    definition?: unknown;
+    connectionMapping?: {
+        [key: string]: string;
+    } | null;
+    isWebhookEntrypoint: boolean;
+};
+type BuildManifestRequest = {
+    workflows: Array<BuildManifestWorkflow>;
+    tables: Array<BuildManifestTable>;
+    connections: Array<ManifestConnection>;
+    version?: string | null;
+    slug?: string | null;
+};
+type PaginatedResponseOfSolutionResponse = {
+    items: Array<SolutionResponse>;
+    totalCount: number;
+    offset: number;
+    top: number;
+};
+type SolutionResponse = {
+    solutionId: number;
+    slug: string;
+    name: string;
+    description?: string | null;
+    iconUrl?: string | null;
+    status: string;
+    manifestVersion: number;
+    installCount: number;
+    createdDate: string;
+    updatedDate?: string | null;
+};
+type SolutionInstallationResponse = {
+    solutionInstallationId: number;
+    solutionId: number;
+    solutionName?: string | null;
+    slug?: string | null;
+    workspaceId: string;
+    environmentId: string;
+    installedManifestVersion: number;
+    autoUpdate: boolean;
+    updateAvailable: boolean;
+    status: string;
+    installedDate: string;
+};
+type InstallationDetailResponse = {
+    solutionInstallationId: number;
+    solutionId: number;
+    solutionName?: string | null;
+    slug?: string | null;
+    workspaceId: string;
+    environmentId: string;
+    installedManifestVersion: number;
+    autoUpdate: boolean;
+    updateAvailable: boolean;
+    status: string;
+    installedDate: string;
+    installedResources: Array<InstalledResourceResponse>;
+};
+type InstalledResourceResponse = {
+    installedResourceId: number;
+    resourceType: string;
+    resourceKey: string;
+    resourceId: string;
+    metadata?: string | null;
+    webhookUrl?: string | null;
+};
+type InstallSolutionResponse = {
+    installationId: number;
+    resources: Array<ProvisionedResourceInfo>;
+};
+type ProvisionedResourceInfo = {
+    resourceType: string;
+    resourceKey: string;
+    resourceId: string;
+    webhookUrl?: string | null;
+    webhookToken?: string | null;
+};
+type InstallSolutionRequest = {
+    workspaceId: string;
+    environmentId: string;
+    existingConnections?: {
+        [key: string]: number;
+    } | null;
+    connectionMapping?: {
+        [key: string]: ConnectionInput;
+    } | null;
+    autoUpdate: boolean;
+    externalContext?: string | null;
+};
+type ConnectionInput = {
+    apiKey?: string | null;
+    baseUrl?: string | null;
+    customKeys?: {
+        [key: string]: string;
+    } | null;
+};
+type UpdateInstallationResponse = {
+    installationId: number;
+    fromVersion: number;
+    toVersion: number;
+    resources: Array<ProvisionedResourceInfo>;
+    brokenWebhookUrls: Array<string>;
+};
+type UpdateBlockedResponse = {
+    blockers: Array<UpdateBlocker>;
+};
+type UpdateBlocker = {
+    type: string;
+    key: string;
+    reason: string;
+};
+type UpdateInstallationRequest = {
+    forceModify: boolean;
+};
+type UninstallSolutionRequest = {
+    installationId: number;
+    deleteConnections: boolean;
+    deleteWorkflows: boolean;
+    deleteTables: boolean;
+};
+type PaginatedResponseOfApplicationDto = {
+    items: Array<ApplicationDto>;
+    totalCount: number;
+    offset: number;
+    top: number;
+};
+type ApplicationDto = {
+    slug: string;
+    applicationName?: string | null;
+    description: string;
+    applicationLogo?: string | null;
+    connectionRequirement: string;
+    categories: Array<string>;
+    toolsCount: number;
+    triggersCount: number;
+};
+type ApplicationDetailDto = ApplicationDto & {
+    supportsObjectSelection?: boolean;
+    helpUrl?: string | null;
+    authenticationMethods?: Array<ApplicationAuthMethod>;
+};
+type ApplicationAuthMethod = {
+    authenticationId: number;
+    authenticationType: string;
+    authenticationName: string;
+    description?: string | null;
+    connectionFields: Array<ApplicationConnectionField>;
+    requiresOAuthSignIn: boolean;
+    oAuthProvider?: string | null;
+};
+type ApplicationConnectionField = {
+    fieldName: string;
+    fieldDescription?: string | null;
+    isRequired: boolean;
+    isRequiredOnSignin: boolean;
+    isHidden: boolean;
+    isPassword: boolean;
+    inputType: AppConnectionFieldInputType;
+    defaultValue?: string | null;
+    tooltip?: string | null;
+    placeholder?: string | null;
+    listValues?: string | null;
+    allowOverride: boolean;
+};
+type AppConnectionFieldInputType = 0 | 1 | 2 | 3;
+type PaginatedResponseOfConnectionPublicListItem = {
+    items: Array<ConnectionPublicListItem>;
+    totalCount: number;
+    offset: number;
+    top: number;
+};
+type ConnectionPublicListItem = {
+    connectionId: number;
+    connectionName: string;
+    description?: string | null;
+    applicationSlug: string;
+    applicationName?: string | null;
+    applicationLogo?: string | null;
+    isPublic: boolean;
+    createdBy: string;
+    createdDate: string;
+    updatedBy?: string | null;
+    updatedDate?: string | null;
+};
+type ConnectionPublicDetail = ConnectionPublicListItem & {
+    authenticationId?: number;
+    authenticationType?: string;
+    fields?: {
+        [key: string]: string | null;
+    };
+    useSelectDBObjects?: boolean;
+    connectionError?: string | null;
+    isAlive?: boolean;
+    metadata?: {
+        [key: string]: string;
+    } | null;
+};
+type CreateConnectionRequest = {
+    applicationSlug: string;
+    connectionName: string;
+    description?: string | null;
+    authenticationId: number;
+    fields: {
+        [key: string]: string;
+    };
+    metadata?: {
+        [key: string]: string;
+    } | null;
+};
+type UpdateConnectionRequest = {
+    connectionName?: string | null;
+    description?: string | null;
+    fields?: {
+        [key: string]: string;
+    } | null;
+    metadata?: {
+        [key: string]: string;
+    } | null;
+};
+type DefaultConnectionsResponse = {
+    items: Array<DefaultConnectionDto>;
+};
+type DefaultConnectionDto = {
+    applicationSlug: string;
+    applicationName?: string | null;
+    connectionId: number;
+    connectionName?: string | null;
+};
+type SetDefaultConnectionResponse = {
+    applicationSlug: string;
+    connectionId: number;
+    isDefault: boolean;
+};
+type ReplaceConnectionRequest = {
+    workflowId: number;
+    originalConnectionId: number;
+    newConnectionId: number;
+};
+type RefreshStatusResponse = {
+    status: RefreshStatus;
+    statusDescription?: string | null;
+    error?: string | null;
+    errorDate?: string | null;
+    lastRefreshDate?: string | null;
+};
+type RefreshStatus = 0 | 1 | 2;
+type SelectObjectsRequest = {
+    objectIds: Array<number>;
+};
+type PaginatedResponseOfConnectionObject = {
+    items: Array<ConnectionObject>;
+    totalCount: number;
+    offset: number;
+    top: number;
+};
+type ConnectionObject = {
+    objectId: number;
+    name: string;
+    type: string;
+    isSelected: boolean;
+};
+type SignInUrlResponse = {
+    signInUrl: string;
+    state: string;
+};
+type SignInUrlRequest = {
+    applicationSlug: string;
+    authenticationId: number;
+    environment?: string | null;
+    fields?: {
+        [key: string]: string;
+    } | null;
+};
+type AccessTokenResponse = {
+    status: string;
+    error_message?: string | null;
+    tokenData: {
+        [key: string]: unknown;
+    };
+    connectionData: {
+        [key: string]: unknown;
+    };
+};
+type PaginatedResponseOfToolDto = {
+    items: Array<ToolDto>;
+    totalCount: number;
+    offset: number;
+    top: number;
+};
+type ToolDto = {
+    toolSlug: string;
+    toolName?: string | null;
+    description?: string | null;
+    category: string;
+    applicationSlug: string;
+    applicationName?: string | null;
+    version?: string | null;
+    isDeprecated: boolean;
+};
+type ToolDetailDto = ToolDto & {
+    inputSchema?: unknown;
+    outputSchema?: unknown;
+    supportsFilters?: boolean;
+    supportsSort?: boolean;
+    supportsTopOffset?: boolean;
+    maxFilters?: number;
+    maxSorts?: number;
+};
+type ToolExecuteResponse = {
+    isSuccess: boolean;
+    errorMessage?: string | null;
+    executionInfo?: ExecutionInfo | null;
+    output?: unknown;
+    historyId?: number | null;
+};
+type ExecutionInfo = {
+    statusCode?: number | null;
+    headers?: {
+        [key: string]: string;
+    } | null;
+    executionTime?: number | null;
+    dataSize?: number | null;
+};
+type ToolExecuteRequest = {
+    fields?: {
+        [key: string]: unknown;
+    } | null;
+    contextValue?: string | null;
+    filters?: Array<ActivityCondition> | null;
+    sort?: Array<ActivitySort> | null;
+    offset?: number | null;
+    top?: number | null;
+    subItems?: {
+        [key: string]: unknown;
+    } | null;
+    customConnectionData?: Array<CustomConnectionDataItem> | null;
+};
+type ActivityCondition = {
+    fieldName: string;
+    operator: string;
+    value: string;
+};
+type ActivitySort = {
+    fieldName: string;
+    orderDirection: OrderDirection;
+};
+type OrderDirection = 1 | -1;
+type CustomConnectionDataItem = {
+    fieldName: string;
+    value: string;
+};
+type PaginatedResponseOfToolsetDto = {
+    items: Array<ToolsetDto>;
+    totalCount: number;
+    offset: number;
+    top: number;
+};
+type ToolsetDto = {
+    toolsetId: string;
+    name: string;
+    connections: Array<ToolsetConnectionDto>;
+    workflows: Array<string>;
+    createdDate: string;
+    updatedDate?: string | null;
+    createdByAccountUserId?: number | null;
+    updatedByAccountUserId?: number | null;
+};
+type ToolsetConnectionDto = {
+    connectionId: number;
+    applicationSlug: string;
+    applicationName?: string | null;
+    toolSlugs: Array<string>;
+};
+type CreateToolsetRequest = {
+    name: string;
+    connections: Array<ToolsetConnectionRequest>;
+    workflows?: Array<string> | null;
+};
+type ToolsetConnectionRequest = {
+    connectionId: number;
+    toolSlugs?: Array<string> | null;
+};
+type UpdateToolsetRequest = {
+    name?: string | null;
+    connections?: Array<ToolsetConnectionRequest> | null;
+    workflows?: Array<string> | null;
+};
+type SolutionsCreateSolutionData = {
+    /**
+     * The solution metadata and build manifest used to create the solution.
+     */
+    body: CreateSolutionRequest;
+    headers?: {
+        /**
+         * Account token. The server resolves the account token from this header OR from the `AccountToken` claim on the Bearer JWT - either alone is sufficient. OAuth-issued JWTs include the claim automatically; password sign-in JWTs do not. If both are sent, the header wins.
+         */
+        companytoken?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/v1/solutions/admin';
+};
+type SolutionsCreateSolutionErrors = {
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    403: ErrorResponse;
+    /**
+     * Not found — the resource does not exist.
+     */
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type SolutionsCreateSolutionError = SolutionsCreateSolutionErrors[keyof SolutionsCreateSolutionErrors];
+type SolutionsCreateSolutionResponses = {
+    /**
+     * The newly created solution along with any manifest build warnings.
+     */
+    200: SolutionAdminWriteResponse;
+};
+type SolutionsCreateSolutionResponse = SolutionsCreateSolutionResponses[keyof SolutionsCreateSolutionResponses];
+type SolutionsArchiveSolutionData = {
+    body?: never;
+    headers?: {
+        /**
+         * Account token. Optional — alternatively send the AccountToken JWT claim.
+         */
+        companytoken?: string;
+    };
+    path: {
+        /**
+         * The slug identifying the solution to archive.
+         */
+        slug: string;
+    };
+    query?: never;
+    url: '/v1/solutions/admin/{slug}';
+};
+type SolutionsArchiveSolutionErrors = {
+    /**
+     * Bad request — malformed body or invalid parameters.
+     */
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    403: ErrorResponse;
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type SolutionsArchiveSolutionError = SolutionsArchiveSolutionErrors[keyof SolutionsArchiveSolutionErrors];
+type SolutionsArchiveSolutionResponses = {
+    /**
+     * No content on success.
+     */
+    204: void;
+};
+type SolutionsArchiveSolutionResponse = SolutionsArchiveSolutionResponses[keyof SolutionsArchiveSolutionResponses];
+type SolutionsUpdateSolutionData = {
+    /**
+     * The updated solution metadata and optional build manifest.
+     */
+    body: UpdateSolutionRequest;
+    headers?: {
+        /**
+         * Account token. The server resolves the account token from this header OR from the `AccountToken` claim on the Bearer JWT - either alone is sufficient. OAuth-issued JWTs include the claim automatically; password sign-in JWTs do not. If both are sent, the header wins.
+         */
+        companytoken?: string;
+    };
+    path: {
+        /**
+         * The slug identifying the solution to update.
+         */
+        slug: string;
+    };
+    query?: never;
+    url: '/v1/solutions/admin/{slug}';
+};
+type SolutionsUpdateSolutionErrors = {
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    403: ErrorResponse;
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type SolutionsUpdateSolutionError = SolutionsUpdateSolutionErrors[keyof SolutionsUpdateSolutionErrors];
+type SolutionsUpdateSolutionResponses = {
+    /**
+     * The updated solution along with any manifest build warnings.
+     */
+    200: SolutionAdminWriteResponse;
+};
+type SolutionsUpdateSolutionResponse = SolutionsUpdateSolutionResponses[keyof SolutionsUpdateSolutionResponses];
+type SolutionsPublishSolutionData = {
+    body?: never;
+    headers?: {
+        /**
+         * Account token. Optional — alternatively send the AccountToken JWT claim.
+         */
+        companytoken?: string;
+    };
+    path: {
+        /**
+         * The slug identifying the solution to publish.
+         */
+        slug: string;
+    };
+    query?: never;
+    url: '/v1/solutions/admin/{slug}/publish';
+};
+type SolutionsPublishSolutionErrors = {
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    403: ErrorResponse;
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type SolutionsPublishSolutionError = SolutionsPublishSolutionErrors[keyof SolutionsPublishSolutionErrors];
+type SolutionsPublishSolutionResponses = {
+    /**
+     * The published solution detail.
+     */
+    200: SolutionDetailResponse;
+};
+type SolutionsPublishSolutionResponse = SolutionsPublishSolutionResponses[keyof SolutionsPublishSolutionResponses];
+type SolutionsBuildManifestData = {
+    /**
+     * The manifest build inputs and an optional slug of an existing solution to update.
+     */
+    body: BuildManifestRequest;
+    headers?: {
+        /**
+         * Account token. The server resolves the account token from this header OR from the `AccountToken` claim on the Bearer JWT - either alone is sufficient. OAuth-issued JWTs include the claim automatically; password sign-in JWTs do not. If both are sent, the header wins.
+         */
+        companytoken?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/v1/solutions/admin/build-manifest';
+};
+type SolutionsBuildManifestErrors = {
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    403: ErrorResponse;
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type SolutionsBuildManifestError = SolutionsBuildManifestErrors[keyof SolutionsBuildManifestErrors];
+type SolutionsBuildManifestResponses = {
+    /**
+     * The built manifest with any warnings, plus the updated solution when a slug was supplied.
+     */
+    200: BuildManifestResponse;
+};
+type SolutionsBuildManifestResponse = SolutionsBuildManifestResponses[keyof SolutionsBuildManifestResponses];
+type SolutionsGetPublishedSolutionsData = {
+    body?: never;
+    headers?: {
+        /**
+         * Account token. Optional — alternatively send the AccountToken JWT claim.
+         */
+        companytoken?: string;
+    };
+    path?: never;
+    query?: {
+        Search?: string | null;
+        Offset?: number;
+        Top?: number;
+    };
+    url: '/v1/solutions';
+};
+type SolutionsGetPublishedSolutionsErrors = {
+    /**
+     * Bad request — malformed body or invalid parameters.
+     */
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    /**
+     * Not found — the resource does not exist.
+     */
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type SolutionsGetPublishedSolutionsError = SolutionsGetPublishedSolutionsErrors[keyof SolutionsGetPublishedSolutionsErrors];
+type SolutionsGetPublishedSolutionsResponses = {
+    /**
+     * A paginated collection of published solutions.
+     */
+    200: PaginatedResponseOfSolutionResponse;
+};
+type SolutionsGetPublishedSolutionsResponse = SolutionsGetPublishedSolutionsResponses[keyof SolutionsGetPublishedSolutionsResponses];
+type SolutionsGetSolutionBySlugData = {
+    body?: never;
+    headers?: {
+        /**
+         * Account token. Optional — alternatively send the AccountToken JWT claim.
+         */
+        companytoken?: string;
+    };
+    path: {
+        /**
+         * The slug identifying the solution to retrieve.
+         */
+        slug: string;
+    };
+    query?: never;
+    url: '/v1/solutions/{slug}';
+};
+type SolutionsGetSolutionBySlugErrors = {
+    /**
+     * Bad request — malformed body or invalid parameters.
+     */
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type SolutionsGetSolutionBySlugError = SolutionsGetSolutionBySlugErrors[keyof SolutionsGetSolutionBySlugErrors];
+type SolutionsGetSolutionBySlugResponses = {
+    /**
+     * The solution detail.
+     */
+    200: SolutionDetailResponse;
+};
+type SolutionsGetSolutionBySlugResponse = SolutionsGetSolutionBySlugResponses[keyof SolutionsGetSolutionBySlugResponses];
+type SolutionsGetInstallationsData = {
+    body?: never;
+    headers?: {
+        /**
+         * Account token. The server resolves the account token from this header OR from the `AccountToken` claim on the Bearer JWT - either alone is sufficient. OAuth-issued JWTs include the claim automatically; password sign-in JWTs do not. If both are sent, the header wins.
+         */
+        companytoken?: string;
+    };
+    path?: never;
+    query?: {
+        /**
+         * Optional solution slug to filter the installations.
+         */
+        slug?: string | null;
+        /**
+         * Optional installation status name to filter by; must be a valid InstallationStatus value.
+         */
+        status?: string | null;
+    };
+    url: '/v1/solutions/installations';
+};
+type SolutionsGetInstallationsErrors = {
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    /**
+     * Not found — the resource does not exist.
+     */
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type SolutionsGetInstallationsError = SolutionsGetInstallationsErrors[keyof SolutionsGetInstallationsErrors];
+type SolutionsGetInstallationsResponses = {
+    /**
+     * The matching installations for the account.
+     */
+    200: Array<SolutionInstallationResponse>;
+};
+type SolutionsGetInstallationsResponse = SolutionsGetInstallationsResponses[keyof SolutionsGetInstallationsResponses];
+type SolutionsGetInstallationDetailData = {
+    body?: never;
+    headers?: {
+        /**
+         * Account token. The server resolves the account token from this header OR from the `AccountToken` claim on the Bearer JWT - either alone is sufficient. OAuth-issued JWTs include the claim automatically; password sign-in JWTs do not. If both are sent, the header wins.
+         */
+        companytoken?: string;
+    };
+    path: {
+        /**
+         * The identifier of the installation to retrieve.
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/solutions/installations/{id}';
+};
+type SolutionsGetInstallationDetailErrors = {
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type SolutionsGetInstallationDetailError = SolutionsGetInstallationDetailErrors[keyof SolutionsGetInstallationDetailErrors];
+type SolutionsGetInstallationDetailResponses = {
+    /**
+     * The installation detail.
+     */
+    200: InstallationDetailResponse;
+};
+type SolutionsGetInstallationDetailResponse = SolutionsGetInstallationDetailResponses[keyof SolutionsGetInstallationDetailResponses];
+type SolutionsGetInstallationResourcesData = {
+    body?: never;
+    headers?: {
+        /**
+         * Account token. The server resolves the account token from this header OR from the `AccountToken` claim on the Bearer JWT - either alone is sufficient. OAuth-issued JWTs include the claim automatically; password sign-in JWTs do not. If both are sent, the header wins.
+         */
+        companytoken?: string;
+    };
+    path: {
+        /**
+         * The identifier of the installation whose resources are requested.
+         */
+        id: number;
+    };
+    query?: {
+        /**
+         * Optional resource key to filter the resources.
+         */
+        resourceKey?: string | null;
+        /**
+         * Optional resource type name to filter by; must be a valid ResourceType value.
+         */
+        resourceType?: string | null;
+    };
+    url: '/v1/solutions/installations/{id}/resources';
+};
+type SolutionsGetInstallationResourcesErrors = {
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type SolutionsGetInstallationResourcesError = SolutionsGetInstallationResourcesErrors[keyof SolutionsGetInstallationResourcesErrors];
+type SolutionsGetInstallationResourcesResponses = {
+    /**
+     * The matching installed resources.
+     */
+    200: Array<InstalledResourceResponse>;
+};
+type SolutionsGetInstallationResourcesResponse = SolutionsGetInstallationResourcesResponses[keyof SolutionsGetInstallationResourcesResponses];
+type SolutionsInstallSolutionData = {
+    /**
+     * The installation options and provisioning inputs.
+     */
+    body: InstallSolutionRequest;
+    headers?: {
+        /**
+         * Account token. The server resolves the account token from this header OR from the `AccountToken` claim on the Bearer JWT - either alone is sufficient. OAuth-issued JWTs include the claim automatically; password sign-in JWTs do not. If both are sent, the header wins.
+         */
+        companytoken?: string;
+    };
+    path: {
+        /**
+         * The slug identifying the solution to install.
+         */
+        slug: string;
+    };
+    query?: never;
+    url: '/v1/solutions/{slug}/install';
+};
+type SolutionsInstallSolutionErrors = {
+    400: ErrorResponse;
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    404: ErrorResponse;
+    409: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type SolutionsInstallSolutionError = SolutionsInstallSolutionErrors[keyof SolutionsInstallSolutionErrors];
+type SolutionsInstallSolutionResponses = {
+    /**
+     * The result of the installation, including the created installation and provisioned resources.
+     */
+    200: InstallSolutionResponse;
+};
+type SolutionsInstallSolutionResponse = SolutionsInstallSolutionResponses[keyof SolutionsInstallSolutionResponses];
+type SolutionsUpdateInstallationData = {
+    /**
+     * Optional update options, including whether to force the update past blockers.
+     */
+    body?: UpdateInstallationRequest;
+    headers?: {
+        /**
+         * Account token. The server resolves the account token from this header OR from the `AccountToken` claim on the Bearer JWT - either alone is sufficient. OAuth-issued JWTs include the claim automatically; password sign-in JWTs do not. If both are sent, the header wins.
+         */
+        companytoken?: string;
+    };
+    path: {
+        /**
+         * The identifier of the installation to update.
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/solutions/installations/{id}/update';
+};
+type SolutionsUpdateInstallationErrors = {
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    404: ErrorResponse;
+    409: UpdateBlockedResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type SolutionsUpdateInstallationError = SolutionsUpdateInstallationErrors[keyof SolutionsUpdateInstallationErrors];
+type SolutionsUpdateInstallationResponses = {
+    /**
+     * The result of the installation update.
+     */
+    200: UpdateInstallationResponse;
+};
+type SolutionsUpdateInstallationResponse = SolutionsUpdateInstallationResponses[keyof SolutionsUpdateInstallationResponses];
+type SolutionsUninstallSolutionData = {
+    /**
+     * The uninstall options, including the installation identifier and which resource types to delete.
+     */
+    body: UninstallSolutionRequest;
+    headers?: {
+        /**
+         * Account token. The server resolves the account token from this header OR from the `AccountToken` claim on the Bearer JWT - either alone is sufficient. OAuth-issued JWTs include the claim automatically; password sign-in JWTs do not. If both are sent, the header wins.
+         */
+        companytoken?: string;
+    };
+    path: {
+        /**
+         * The slug identifying the solution to uninstall.
+         */
+        slug: string;
+    };
+    query?: never;
+    url: '/v1/solutions/{slug}/uninstall';
+};
+type SolutionsUninstallSolutionErrors = {
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type SolutionsUninstallSolutionError = SolutionsUninstallSolutionErrors[keyof SolutionsUninstallSolutionErrors];
+type SolutionsUninstallSolutionResponses = {
+    /**
+     * No content on success.
+     */
+    204: void;
+};
+type SolutionsUninstallSolutionResponse = SolutionsUninstallSolutionResponses[keyof SolutionsUninstallSolutionResponses];
+type ApplicationsListApplicationsData = {
+    body?: never;
+    headers?: {
+        /**
+         * Account token. Optional — alternatively send the AccountToken JWT claim.
+         */
+        companytoken?: string;
+    };
+    path?: never;
+    query?: {
+        /**
+         * Optional free-text search applied across application fields.
+         */
+        search?: string | null;
+        /**
+         * Optional exact-name filter.
+         */
+        name?: string | null;
+        /**
+         * Optional filter on the application's connection requirement.
+         */
+        connectionRequirement?: string | null;
+        /**
+         * Optional list of categories to filter by.
+         */
+        category?: Array<string> | null;
+        /**
+         * When true, returns only applications the caller can currently use. Defaults to false.
+         */
+        available?: boolean;
+        /**
+         * Zero-based index of the first item to return. Defaults to 0.
+         */
+        offset?: number;
+        /**
+         * Maximum number of items to return. Defaults to 100.
+         */
+        top?: number;
+    };
+    url: '/v1/applications';
+};
+type ApplicationsListApplicationsErrors = {
+    400: ErrorResponse;
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    /**
+     * Not found — the resource does not exist.
+     */
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type ApplicationsListApplicationsError = ApplicationsListApplicationsErrors[keyof ApplicationsListApplicationsErrors];
+type ApplicationsListApplicationsResponses = {
+    /**
+     * A paginated list of applications.
+     */
+    200: PaginatedResponseOfApplicationDto;
+};
+type ApplicationsListApplicationsResponse = ApplicationsListApplicationsResponses[keyof ApplicationsListApplicationsResponses];
+type ApplicationsGetApplicationData = {
+    body?: never;
+    headers?: {
+        /**
+         * Account token. Optional — alternatively send the AccountToken JWT claim.
+         */
+        companytoken?: string;
+    };
+    path: {
+        /**
+         * The slug identifying the application to retrieve.
+         */
+        slug: string;
+    };
+    query?: never;
+    url: '/v1/applications/{slug}';
+};
+type ApplicationsGetApplicationErrors = {
+    /**
+     * Bad request — malformed body or invalid parameters.
+     */
+    400: ErrorResponse;
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type ApplicationsGetApplicationError = ApplicationsGetApplicationErrors[keyof ApplicationsGetApplicationErrors];
+type ApplicationsGetApplicationResponses = {
+    /**
+     * The detailed representation of the application.
+     */
+    200: ApplicationDetailDto;
+};
+type ApplicationsGetApplicationResponse = ApplicationsGetApplicationResponses[keyof ApplicationsGetApplicationResponses];
+type ConnectionsGetConnectionsData = {
+    body?: never;
+    headers?: {
+        /**
+         * Account token. Optional — alternatively send the AccountToken JWT claim.
+         */
+        companytoken?: string;
+    };
+    path?: never;
+    query?: {
+        /**
+         * Optional filter limiting results to connections of a specific application.
+         */
+        applicationSlug?: string | null;
+        /**
+         * Optional name filter.
+         */
+        name?: string | null;
+        /**
+         * Zero-based index of the first item to return. Defaults to 0.
+         */
+        offset?: number;
+        /**
+         * Maximum number of items to return (capped at 100). Defaults to 25.
+         */
+        top?: number;
+        /**
+         * Optional metadata key/value pairs to filter connections by.
+         */
+        metadata?: {
+            [key: string]: string;
+        } | null;
+    };
+    url: '/v1/connections';
+};
+type ConnectionsGetConnectionsErrors = {
+    /**
+     * Bad request — malformed body or invalid parameters.
+     */
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    /**
+     * Not found — the resource does not exist.
+     */
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type ConnectionsGetConnectionsError = ConnectionsGetConnectionsErrors[keyof ConnectionsGetConnectionsErrors];
+type ConnectionsGetConnectionsResponses = {
+    /**
+     * A paginated list of connections.
+     */
+    200: PaginatedResponseOfConnectionPublicListItem;
+};
+type ConnectionsGetConnectionsResponse = ConnectionsGetConnectionsResponses[keyof ConnectionsGetConnectionsResponses];
+type ConnectionsCreateConnectionData = {
+    /**
+     * The connection creation payload, including the connection name and application slug.
+     */
+    body: CreateConnectionRequest;
+    headers?: {
+        /**
+         * Account token. Optional — alternatively send the AccountToken JWT claim.
+         */
+        companytoken?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/v1/connections';
+};
+type ConnectionsCreateConnectionErrors = {
+    /**
+     * Bad request — malformed body or invalid parameters.
+     */
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    /**
+     * Not found — the resource does not exist.
+     */
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type ConnectionsCreateConnectionError = ConnectionsCreateConnectionErrors[keyof ConnectionsCreateConnectionErrors];
+type ConnectionsCreateConnectionResponses = {
+    /**
+     * The newly created connection.
+     */
+    200: ConnectionPublicDetail;
+};
+type ConnectionsCreateConnectionResponse = ConnectionsCreateConnectionResponses[keyof ConnectionsCreateConnectionResponses];
+type ConnectionsDeleteConnectionData = {
+    body?: never;
+    headers?: {
+        /**
+         * Account token. Optional — alternatively send the AccountToken JWT claim.
+         */
+        companytoken?: string;
+    };
+    path: {
+        /**
+         * The identifier of the connection to delete.
+         */
+        connectionId: number;
+    };
+    query?: never;
+    url: '/v1/connections/{connectionId}';
+};
+type ConnectionsDeleteConnectionErrors = {
+    /**
+     * Bad request — malformed body or invalid parameters.
+     */
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    /**
+     * Not found — the resource does not exist.
+     */
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type ConnectionsDeleteConnectionError = ConnectionsDeleteConnectionErrors[keyof ConnectionsDeleteConnectionErrors];
+type ConnectionsDeleteConnectionResponses = {
+    /**
+     * An empty success response when the connection is deleted.
+     */
+    200: Blob | File;
+};
+type ConnectionsDeleteConnectionResponse = ConnectionsDeleteConnectionResponses[keyof ConnectionsDeleteConnectionResponses];
+type ConnectionsGetConnectionData = {
+    body?: never;
+    headers?: {
+        /**
+         * Account token. Optional — alternatively send the AccountToken JWT claim.
+         */
+        companytoken?: string;
+    };
+    path: {
+        /**
+         * The identifier of the connection to retrieve.
+         */
+        connectionId: number;
+    };
+    query?: never;
+    url: '/v1/connections/{connectionId}';
+};
+type ConnectionsGetConnectionErrors = {
+    /**
+     * Bad request — malformed body or invalid parameters.
+     */
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    /**
+     * Not found — the resource does not exist.
+     */
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type ConnectionsGetConnectionError = ConnectionsGetConnectionErrors[keyof ConnectionsGetConnectionErrors];
+type ConnectionsGetConnectionResponses = {
+    /**
+     * The detailed representation of the connection.
+     */
+    200: ConnectionPublicDetail;
+};
+type ConnectionsGetConnectionResponse = ConnectionsGetConnectionResponses[keyof ConnectionsGetConnectionResponses];
+type ConnectionsUpdateConnectionData = {
+    /**
+     * The fields to update on the connection.
+     */
+    body: UpdateConnectionRequest;
+    headers?: {
+        /**
+         * Account token. Optional — alternatively send the AccountToken JWT claim.
+         */
+        companytoken?: string;
+    };
+    path: {
+        /**
+         * The identifier of the connection to update.
+         */
+        connectionId: number;
+    };
+    query?: never;
+    url: '/v1/connections/{connectionId}';
+};
+type ConnectionsUpdateConnectionErrors = {
+    /**
+     * Bad request — malformed body or invalid parameters.
+     */
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    /**
+     * Not found — the resource does not exist.
+     */
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type ConnectionsUpdateConnectionError = ConnectionsUpdateConnectionErrors[keyof ConnectionsUpdateConnectionErrors];
+type ConnectionsUpdateConnectionResponses = {
+    /**
+     * The updated connection.
+     */
+    200: ConnectionPublicDetail;
+};
+type ConnectionsUpdateConnectionResponse = ConnectionsUpdateConnectionResponses[keyof ConnectionsUpdateConnectionResponses];
+type ConnectionsGetDefaultConnectionsData = {
+    body?: never;
+    headers?: {
+        /**
+         * Account token. Optional — alternatively send the AccountToken JWT claim.
+         */
+        companytoken?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/v1/connections/Defaults';
+};
+type ConnectionsGetDefaultConnectionsErrors = {
+    /**
+     * Bad request — malformed body or invalid parameters.
+     */
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    /**
+     * Not found — the resource does not exist.
+     */
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type ConnectionsGetDefaultConnectionsError = ConnectionsGetDefaultConnectionsErrors[keyof ConnectionsGetDefaultConnectionsErrors];
+type ConnectionsGetDefaultConnectionsResponses = {
+    /**
+     * The caller's default connections.
+     */
+    200: DefaultConnectionsResponse;
+};
+type ConnectionsGetDefaultConnectionsResponse = ConnectionsGetDefaultConnectionsResponses[keyof ConnectionsGetDefaultConnectionsResponses];
+type ConnectionsClearDefaultConnectionData = {
+    body?: never;
+    headers?: {
+        /**
+         * Account token. Optional — alternatively send the AccountToken JWT claim.
+         */
+        companytoken?: string;
+    };
+    path: {
+        /**
+         * The identifier of the connection to clear as default.
+         */
+        connectionId: number;
+    };
+    query?: never;
+    url: '/v1/connections/{connectionId}/Default';
+};
+type ConnectionsClearDefaultConnectionErrors = {
+    /**
+     * Bad request — malformed body or invalid parameters.
+     */
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    /**
+     * Not found — the resource does not exist.
+     */
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type ConnectionsClearDefaultConnectionError = ConnectionsClearDefaultConnectionErrors[keyof ConnectionsClearDefaultConnectionErrors];
+type ConnectionsClearDefaultConnectionResponses = {
+    /**
+     * No content when the default is cleared successfully.
+     */
+    200: Blob | File;
+};
+type ConnectionsClearDefaultConnectionResponse = ConnectionsClearDefaultConnectionResponses[keyof ConnectionsClearDefaultConnectionResponses];
+type ConnectionsSetDefaultConnectionData = {
+    body?: never;
+    headers?: {
+        /**
+         * Account token. Optional — alternatively send the AccountToken JWT claim.
+         */
+        companytoken?: string;
+    };
+    path: {
+        /**
+         * The identifier of the connection to mark as default.
+         */
+        connectionId: number;
+    };
+    query?: never;
+    url: '/v1/connections/{connectionId}/Default';
+};
+type ConnectionsSetDefaultConnectionErrors = {
+    /**
+     * Bad request — malformed body or invalid parameters.
+     */
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    /**
+     * Not found — the resource does not exist.
+     */
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type ConnectionsSetDefaultConnectionError = ConnectionsSetDefaultConnectionErrors[keyof ConnectionsSetDefaultConnectionErrors];
+type ConnectionsSetDefaultConnectionResponses = {
+    /**
+     * The result of setting the default connection.
+     */
+    200: SetDefaultConnectionResponse;
+};
+type ConnectionsSetDefaultConnectionResponse = ConnectionsSetDefaultConnectionResponses[keyof ConnectionsSetDefaultConnectionResponses];
+type ConnectionsReplaceConnectionData = {
+    /**
+     * The replacement payload identifying the source and target connections.
+     */
+    body: ReplaceConnectionRequest;
+    headers?: {
+        /**
+         * Account token. Optional — alternatively send the AccountToken JWT claim.
+         */
+        companytoken?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/v1/connections/Replace';
+};
+type ConnectionsReplaceConnectionErrors = {
+    /**
+     * Bad request — malformed body or invalid parameters.
+     */
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    /**
+     * Not found — the resource does not exist.
+     */
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type ConnectionsReplaceConnectionError = ConnectionsReplaceConnectionErrors[keyof ConnectionsReplaceConnectionErrors];
+type ConnectionsReplaceConnectionResponses = {
+    /**
+     * An empty success response when the replacement completes.
+     */
+    200: Blob | File;
+};
+type ConnectionsReplaceConnectionResponse = ConnectionsReplaceConnectionResponses[keyof ConnectionsReplaceConnectionResponses];
+type ConnectionsRefreshObjectsData = {
+    body?: never;
+    headers?: {
+        /**
+         * Account token. Optional — alternatively send the AccountToken JWT claim.
+         */
+        companytoken?: string;
+    };
+    path: {
+        /**
+         * The identifier of the connection whose objects should be refreshed.
+         */
+        connectionId: number;
+    };
+    query?: never;
+    url: '/v1/connections/{connectionId}/RefreshObjects';
+};
+type ConnectionsRefreshObjectsErrors = {
+    /**
+     * Bad request — malformed body or invalid parameters.
+     */
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    /**
+     * Not found — the resource does not exist.
+     */
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type ConnectionsRefreshObjectsError = ConnectionsRefreshObjectsErrors[keyof ConnectionsRefreshObjectsErrors];
+type ConnectionsRefreshObjectsResponses = {
+    /**
+     * An empty success response when the refresh is initiated.
+     */
+    200: Blob | File;
+};
+type ConnectionsRefreshObjectsResponse = ConnectionsRefreshObjectsResponses[keyof ConnectionsRefreshObjectsResponses];
+type ConnectionsGetRefreshStatusData = {
+    body?: never;
+    headers?: {
+        /**
+         * Account token. Optional — alternatively send the AccountToken JWT claim.
+         */
+        companytoken?: string;
+    };
+    path: {
+        /**
+         * The identifier of the connection whose refresh status is requested.
+         */
+        connectionId: number;
+    };
+    query?: never;
+    url: '/v1/connections/{connectionId}/RefreshStatus';
+};
+type ConnectionsGetRefreshStatusErrors = {
+    /**
+     * Bad request — malformed body or invalid parameters.
+     */
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    /**
+     * Not found — the resource does not exist.
+     */
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type ConnectionsGetRefreshStatusError = ConnectionsGetRefreshStatusErrors[keyof ConnectionsGetRefreshStatusErrors];
+type ConnectionsGetRefreshStatusResponses = {
+    /**
+     * The current refresh status for the connection.
+     */
+    200: RefreshStatusResponse;
+};
+type ConnectionsGetRefreshStatusResponse = ConnectionsGetRefreshStatusResponses[keyof ConnectionsGetRefreshStatusResponses];
+type ConnectionsSelectObjectsData = {
+    /**
+     * The request containing the identifiers of the objects to select.
+     */
+    body: SelectObjectsRequest;
+    headers?: {
+        /**
+         * Account token. Optional — alternatively send the AccountToken JWT claim.
+         */
+        companytoken?: string;
+    };
+    path: {
+        /**
+         * The identifier of the connection whose objects are being selected.
+         */
+        connectionId: number;
+    };
+    query?: never;
+    url: '/v1/connections/{connectionId}/SelectObjects';
+};
+type ConnectionsSelectObjectsErrors = {
+    /**
+     * Bad request — malformed body or invalid parameters.
+     */
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    /**
+     * Not found — the resource does not exist.
+     */
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type ConnectionsSelectObjectsError = ConnectionsSelectObjectsErrors[keyof ConnectionsSelectObjectsErrors];
+type ConnectionsSelectObjectsResponses = {
+    /**
+     * An empty success response when the selection is saved.
+     */
+    200: Blob | File;
+};
+type ConnectionsSelectObjectsResponse = ConnectionsSelectObjectsResponses[keyof ConnectionsSelectObjectsResponses];
+type ConnectionsGetConnectionObjectsData = {
+    body?: never;
+    headers?: {
+        /**
+         * Account token. Optional — alternatively send the AccountToken JWT claim.
+         */
+        companytoken?: string;
+    };
+    path: {
+        /**
+         * The identifier of the connection whose objects are listed.
+         */
+        connectionId: number;
+    };
+    query?: {
+        /**
+         * Optional name filter applied to the objects.
+         */
+        name?: string | null;
+        /**
+         * Optional sort expression for ordering the objects.
+         */
+        sort?: string | null;
+        /**
+         * Zero-based index of the first item to return. Defaults to 0.
+         */
+        offset?: number;
+        /**
+         * Maximum number of items to return (capped at 1000). Defaults to 100.
+         */
+        top?: number;
+    };
+    url: '/v1/connections/{connectionId}/Objects';
+};
+type ConnectionsGetConnectionObjectsErrors = {
+    /**
+     * Bad request — malformed body or invalid parameters.
+     */
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    /**
+     * Not found — the resource does not exist.
+     */
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type ConnectionsGetConnectionObjectsError = ConnectionsGetConnectionObjectsErrors[keyof ConnectionsGetConnectionObjectsErrors];
+type ConnectionsGetConnectionObjectsResponses = {
+    /**
+     * A paginated list of connection objects.
+     */
+    200: PaginatedResponseOfConnectionObject;
+};
+type ConnectionsGetConnectionObjectsResponse = ConnectionsGetConnectionObjectsResponses[keyof ConnectionsGetConnectionObjectsResponses];
+type ConnectionsCheckConnectionData = {
+    body?: never;
+    headers?: {
+        /**
+         * Account token. Optional — alternatively send the AccountToken JWT claim.
+         */
+        companytoken?: string;
+    };
+    path: {
+        /**
+         * The identifier of the connection to check.
+         */
+        connectionId: number;
+    };
+    query?: never;
+    url: '/v1/connections/{connectionId}/Check';
+};
+type ConnectionsCheckConnectionErrors = {
+    /**
+     * Bad request — malformed body or invalid parameters.
+     */
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    /**
+     * Not found — the resource does not exist.
+     */
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type ConnectionsCheckConnectionError = ConnectionsCheckConnectionErrors[keyof ConnectionsCheckConnectionErrors];
+type ConnectionsCheckConnectionResponses = {
+    /**
+     * An empty success response when the connection is healthy.
+     */
+    200: Blob | File;
+};
+type ConnectionsCheckConnectionResponse = ConnectionsCheckConnectionResponses[keyof ConnectionsCheckConnectionResponses];
+type ConnectionsGetSignInUrlData = {
+    /**
+     * The request describing the application, authentication method, and any provider fields.
+     */
+    body: SignInUrlRequest;
+    headers?: {
+        /**
+         * Account token. Optional — alternatively send the AccountToken JWT claim.
+         */
+        companytoken?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/v1/connections/GetSignInUrl';
+};
+type ConnectionsGetSignInUrlErrors = {
+    /**
+     * Bad request — malformed body or invalid parameters.
+     */
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    /**
+     * Not found — the resource does not exist.
+     */
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type ConnectionsGetSignInUrlError = ConnectionsGetSignInUrlErrors[keyof ConnectionsGetSignInUrlErrors];
+type ConnectionsGetSignInUrlResponses = {
+    /**
+     * The sign-in URL together with the generated state value used to correlate the callback.
+     */
+    200: SignInUrlResponse;
+};
+type ConnectionsGetSignInUrlResponse = ConnectionsGetSignInUrlResponses[keyof ConnectionsGetSignInUrlResponses];
+type ConnectionsGetAccessTokenData = {
+    body?: never;
+    headers?: {
+        /**
+         * Account token. Optional — alternatively send the AccountToken JWT claim.
+         */
+        companytoken?: string;
+    };
+    path: {
+        /**
+         * The state value returned when the sign-in URL was generated.
+         */
+        state: string;
+    };
+    query?: never;
+    url: '/v1/connections/AccessToken/{state}';
+};
+type ConnectionsGetAccessTokenErrors = {
+    /**
+     * Bad request — malformed body or invalid parameters.
+     */
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    /**
+     * Not found — the resource does not exist.
+     */
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type ConnectionsGetAccessTokenError = ConnectionsGetAccessTokenErrors[keyof ConnectionsGetAccessTokenErrors];
+type ConnectionsGetAccessTokenResponses = {
+    /**
+     * The access token data for the state, or null if no token has been captured yet.
+     */
+    200: AccessTokenResponse;
+};
+type ConnectionsGetAccessTokenResponse = ConnectionsGetAccessTokenResponses[keyof ConnectionsGetAccessTokenResponses];
+type ToolsListToolsData = {
+    body?: never;
+    headers?: {
+        /**
+         * Account token. Optional — alternatively send the AccountToken JWT claim.
+         */
+        companytoken?: string;
+    };
+    path?: never;
+    query?: {
+        /**
+         * Optional free-text search applied across tool fields.
+         */
+        search?: string | null;
+        /**
+         * Optional exact-name filter.
+         */
+        name?: string | null;
+        /**
+         * Optional filter limiting results to tools of a specific application.
+         */
+        applicationSlug?: string | null;
+        /**
+         * Optional category filter.
+         */
+        category?: string | null;
+        /**
+         * When true, returns only tools the caller can currently execute. Defaults to false.
+         */
+        available?: boolean;
+        /**
+         * When true, includes deprecated tools in the results. Defaults to false.
+         */
+        includeDeprecated?: boolean;
+        /**
+         * Zero-based index of the first item to return. Defaults to 0.
+         */
+        offset?: number;
+        /**
+         * Maximum number of items to return. Defaults to 100.
+         */
+        top?: number;
+    };
+    url: '/v1/tools';
+};
+type ToolsListToolsErrors = {
+    400: ErrorResponse;
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    /**
+     * Not found — the resource does not exist.
+     */
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type ToolsListToolsError = ToolsListToolsErrors[keyof ToolsListToolsErrors];
+type ToolsListToolsResponses = {
+    /**
+     * A paginated list of tools.
+     */
+    200: PaginatedResponseOfToolDto;
+};
+type ToolsListToolsResponse = ToolsListToolsResponses[keyof ToolsListToolsResponses];
+type ToolsGetToolData = {
+    body?: never;
+    headers?: {
+        /**
+         * Account token. Optional — alternatively send the AccountToken JWT claim.
+         */
+        companytoken?: string;
+    };
+    path: {
+        /**
+         * The slug identifying the tool to retrieve.
+         */
+        toolSlug: string;
+    };
+    query?: {
+        /**
+         * Optional parent-application slug used to disambiguate when the same tool slug exists across applications.
+         */
+        applicationSlug?: string | null;
+    };
+    url: '/v1/tools/{toolSlug}';
+};
+type ToolsGetToolErrors = {
+    400: ErrorResponse;
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type ToolsGetToolError = ToolsGetToolErrors[keyof ToolsGetToolErrors];
+type ToolsGetToolResponses = {
+    /**
+     * The detailed representation of the tool.
+     */
+    200: ToolDetailDto;
+};
+type ToolsGetToolResponse = ToolsGetToolResponses[keyof ToolsGetToolResponses];
+type ToolsExecuteToolData = {
+    /**
+     * The execution request containing the tool's input arguments.
+     */
+    body: ToolExecuteRequest;
+    headers?: {
+        /**
+         * Account token. Optional — alternatively send the AccountToken JWT claim.
+         */
+        companytoken?: string;
+    };
+    path: {
+        /**
+         * The slug identifying the tool to execute.
+         */
+        toolSlug: string;
+    };
+    query?: {
+        /**
+         * Optional parent-application slug used to disambiguate the tool and resolve the connection.
+         */
+        applicationSlug?: string | null;
+        /**
+         * Optional toolset identifier used to scope connection resolution.
+         */
+        toolsetId?: string | null;
+        /**
+         * Optional explicit connection identifier to use instead of the implicitly resolved connection.
+         */
+        connectionId?: number | null;
+    };
+    url: '/v1/tools/{toolSlug}/execute';
+};
+type ToolsExecuteToolErrors = {
+    400: ErrorResponse;
+    401: ErrorResponse;
+    403: ErrorResponse;
+    404: ErrorResponse;
+    409: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type ToolsExecuteToolError = ToolsExecuteToolErrors[keyof ToolsExecuteToolErrors];
+type ToolsExecuteToolResponses = {
+    /**
+     * The tool execution result, including success status and any output.
+     */
+    200: ToolExecuteResponse;
+};
+type ToolsExecuteToolResponse = ToolsExecuteToolResponses[keyof ToolsExecuteToolResponses];
+type ToolsetsListToolsetsData = {
+    body?: never;
+    headers?: {
+        /**
+         * Account token. Optional — alternatively send the AccountToken JWT claim.
+         */
+        companytoken?: string;
+    };
+    path?: never;
+    query?: {
+        /**
+         * Zero-based index of the first item to return. Defaults to 0.
+         */
+        offset?: number;
+        /**
+         * Maximum number of items to return (capped at 100). Defaults to 100.
+         */
+        top?: number;
+    };
+    url: '/v1/toolsets';
+};
+type ToolsetsListToolsetsErrors = {
+    /**
+     * Bad request — malformed body or invalid parameters.
+     */
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    /**
+     * Not found — the resource does not exist.
+     */
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type ToolsetsListToolsetsError = ToolsetsListToolsetsErrors[keyof ToolsetsListToolsetsErrors];
+type ToolsetsListToolsetsResponses = {
+    /**
+     * A paginated list of toolsets.
+     */
+    200: PaginatedResponseOfToolsetDto;
+};
+type ToolsetsListToolsetsResponse = ToolsetsListToolsetsResponses[keyof ToolsetsListToolsetsResponses];
+type ToolsetsCreateToolsetData = {
+    /**
+     * The toolset creation payload.
+     */
+    body: CreateToolsetRequest;
+    headers?: {
+        /**
+         * Account token. Optional — alternatively send the AccountToken JWT claim.
+         */
+        companytoken?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/v1/toolsets';
+};
+type ToolsetsCreateToolsetErrors = {
+    /**
+     * Bad request — malformed body or invalid parameters.
+     */
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    /**
+     * Not found — the resource does not exist.
+     */
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type ToolsetsCreateToolsetError = ToolsetsCreateToolsetErrors[keyof ToolsetsCreateToolsetErrors];
+type ToolsetsCreateToolsetResponses = {
+    /**
+     * The newly created toolset.
+     */
+    200: ToolsetDto;
+};
+type ToolsetsCreateToolsetResponse = ToolsetsCreateToolsetResponses[keyof ToolsetsCreateToolsetResponses];
+type ToolsetsDeleteToolsetData = {
+    body?: never;
+    headers?: {
+        /**
+         * Account token. Optional — alternatively send the AccountToken JWT claim.
+         */
+        companytoken?: string;
+    };
+    path: {
+        /**
+         * The identifier of the toolset to delete.
+         */
+        toolsetId: string;
+    };
+    query?: never;
+    url: '/v1/toolsets/{toolsetId}';
+};
+type ToolsetsDeleteToolsetErrors = {
+    /**
+     * Bad request — malformed body or invalid parameters.
+     */
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    /**
+     * Not found — the resource does not exist.
+     */
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type ToolsetsDeleteToolsetError = ToolsetsDeleteToolsetErrors[keyof ToolsetsDeleteToolsetErrors];
+type ToolsetsDeleteToolsetResponses = {
+    /**
+     * No content when the toolset is deleted successfully.
+     */
+    200: Blob | File;
+};
+type ToolsetsDeleteToolsetResponse = ToolsetsDeleteToolsetResponses[keyof ToolsetsDeleteToolsetResponses];
+type ToolsetsGetToolsetData = {
+    body?: never;
+    headers?: {
+        /**
+         * Account token. Optional — alternatively send the AccountToken JWT claim.
+         */
+        companytoken?: string;
+    };
+    path: {
+        /**
+         * The identifier of the toolset to retrieve.
+         */
+        toolsetId: string;
+    };
+    query?: never;
+    url: '/v1/toolsets/{toolsetId}';
+};
+type ToolsetsGetToolsetErrors = {
+    /**
+     * Bad request — malformed body or invalid parameters.
+     */
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    /**
+     * Not found — the resource does not exist.
+     */
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type ToolsetsGetToolsetError = ToolsetsGetToolsetErrors[keyof ToolsetsGetToolsetErrors];
+type ToolsetsGetToolsetResponses = {
+    /**
+     * The requested toolset.
+     */
+    200: ToolsetDto;
+};
+type ToolsetsGetToolsetResponse = ToolsetsGetToolsetResponses[keyof ToolsetsGetToolsetResponses];
+type ToolsetsUpdateToolsetData = {
+    /**
+     * The fields to update on the toolset.
+     */
+    body: UpdateToolsetRequest;
+    headers?: {
+        /**
+         * Account token. Optional — alternatively send the AccountToken JWT claim.
+         */
+        companytoken?: string;
+    };
+    path: {
+        /**
+         * The identifier of the toolset to update.
+         */
+        toolsetId: string;
+    };
+    query?: never;
+    url: '/v1/toolsets/{toolsetId}';
+};
+type ToolsetsUpdateToolsetErrors = {
+    /**
+     * Bad request — malformed body or invalid parameters.
+     */
+    400: ErrorResponse;
+    /**
+     * Unauthorized — missing or invalid bearer token.
+     */
+    401: ErrorResponse;
+    /**
+     * Forbidden — the caller lacks access to the resource.
+     */
+    403: ErrorResponse;
+    /**
+     * Not found — the resource does not exist.
+     */
+    404: ErrorResponse;
+    /**
+     * Too many requests — rate limit exceeded.
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error — an unexpected error occurred.
+     */
+    500: ErrorResponse;
+};
+type ToolsetsUpdateToolsetError = ToolsetsUpdateToolsetErrors[keyof ToolsetsUpdateToolsetErrors];
+type ToolsetsUpdateToolsetResponses = {
+    /**
+     * The updated toolset.
+     */
+    200: ToolsetDto;
+};
+type ToolsetsUpdateToolsetResponse = ToolsetsUpdateToolsetResponses[keyof ToolsetsUpdateToolsetResponses];
+
+type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = Options$1<TData, ThrowOnError, TResponse> & {
+    /**
+     * You can provide a client instance returned by `createClient()` instead of
+     * individual options. This might be also useful if you want to implement a
+     * custom client.
+     */
+    client?: Client;
+    /**
+     * You can pass arbitrary values through the `meta` object. This can be
+     * used to access values that aren't defined as part of the SDK function.
+     */
+    meta?: Record<string, unknown>;
+};
+/**
+ * Creates a new solution (Engini admin only). The request's build manifest is compiled into a
+ * stored manifest, and the resulting solution is returned together with any build warnings.
+ */
+declare const solutionsCreateSolution: <ThrowOnError extends boolean = false>(options: Options<SolutionsCreateSolutionData, ThrowOnError>) => RequestResult<SolutionsCreateSolutionResponses, SolutionsCreateSolutionErrors, ThrowOnError>;
+/**
+ * Archives the solution identified by its slug (Engini admin only), removing it from the published catalog.
+ */
+declare const solutionsArchiveSolution: <ThrowOnError extends boolean = false>(options: Options<SolutionsArchiveSolutionData, ThrowOnError>) => RequestResult<SolutionsArchiveSolutionResponses, SolutionsArchiveSolutionErrors, ThrowOnError>;
+/**
+ * Updates an existing solution identified by its slug (Engini admin only). When a build manifest
+ * is supplied, the manifest is rebuilt and persisted; otherwise only the solution metadata is updated.
+ */
+declare const solutionsUpdateSolution: <ThrowOnError extends boolean = false>(options: Options<SolutionsUpdateSolutionData, ThrowOnError>) => RequestResult<SolutionsUpdateSolutionResponses, SolutionsUpdateSolutionErrors, ThrowOnError>;
+/**
+ * Publishes the solution identified by its slug (Engini admin only), making it available in the public catalog.
+ */
+declare const solutionsPublishSolution: <ThrowOnError extends boolean = false>(options: Options<SolutionsPublishSolutionData, ThrowOnError>) => RequestResult<SolutionsPublishSolutionResponses, SolutionsPublishSolutionErrors, ThrowOnError>;
+/**
+ * Builds a solution manifest from the supplied workflows, tables, and connections (Engini admin only).
+ * When a slug is provided, the freshly built manifest is also persisted onto the existing solution,
+ * bumping its manifest version and notifying installations.
+ */
+declare const solutionsBuildManifest: <ThrowOnError extends boolean = false>(options: Options<SolutionsBuildManifestData, ThrowOnError>) => RequestResult<SolutionsBuildManifestResponses, SolutionsBuildManifestErrors, ThrowOnError>;
+/**
+ * Returns a paginated list of published solutions from the public catalog.
+ */
+declare const solutionsGetPublishedSolutions: <ThrowOnError extends boolean = false>(options?: Options<SolutionsGetPublishedSolutionsData, ThrowOnError>) => RequestResult<SolutionsGetPublishedSolutionsResponses, SolutionsGetPublishedSolutionsErrors, ThrowOnError>;
+/**
+ * Returns the detail of a single published solution identified by its slug.
+ */
+declare const solutionsGetSolutionBySlug: <ThrowOnError extends boolean = false>(options: Options<SolutionsGetSolutionBySlugData, ThrowOnError>) => RequestResult<SolutionsGetSolutionBySlugResponses, SolutionsGetSolutionBySlugErrors, ThrowOnError>;
+/**
+ * Returns the solution installations belonging to the calling account, optionally filtered by
+ * solution slug and installation status.
+ */
+declare const solutionsGetInstallations: <ThrowOnError extends boolean = false>(options?: Options<SolutionsGetInstallationsData, ThrowOnError>) => RequestResult<SolutionsGetInstallationsResponses, SolutionsGetInstallationsErrors, ThrowOnError>;
+/**
+ * Returns the detail of a single installation belonging to the calling account.
+ */
+declare const solutionsGetInstallationDetail: <ThrowOnError extends boolean = false>(options: Options<SolutionsGetInstallationDetailData, ThrowOnError>) => RequestResult<SolutionsGetInstallationDetailResponses, SolutionsGetInstallationDetailErrors, ThrowOnError>;
+/**
+ * Returns the provisioned resources for a given installation belonging to the calling account,
+ * optionally filtered by resource key and resource type.
+ */
+declare const solutionsGetInstallationResources: <ThrowOnError extends boolean = false>(options: Options<SolutionsGetInstallationResourcesData, ThrowOnError>) => RequestResult<SolutionsGetInstallationResourcesResponses, SolutionsGetInstallationResourcesErrors, ThrowOnError>;
+/**
+ * Installs the solution identified by its slug into the calling account's workspace, provisioning
+ * the solution's resources. This endpoint is rate limited.
+ */
+declare const solutionsInstallSolution: <ThrowOnError extends boolean = false>(options: Options<SolutionsInstallSolutionData, ThrowOnError>) => RequestResult<SolutionsInstallSolutionResponses, SolutionsInstallSolutionErrors, ThrowOnError>;
+/**
+ * Updates an existing installation to the latest solution manifest version, re-provisioning resources
+ * as needed. Returns a 409 with the blocking conditions when the update is blocked and not forced.
+ * This endpoint is rate limited.
+ */
+declare const solutionsUpdateInstallation: <ThrowOnError extends boolean = false>(options: Options<SolutionsUpdateInstallationData, ThrowOnError>) => RequestResult<SolutionsUpdateInstallationResponses, SolutionsUpdateInstallationErrors, ThrowOnError>;
+/**
+ * Uninstalls a solution installation from the calling account's workspace, optionally deleting the
+ * associated connections, workflows, and tables. This endpoint is rate limited.
+ */
+declare const solutionsUninstallSolution: <ThrowOnError extends boolean = false>(options: Options<SolutionsUninstallSolutionData, ThrowOnError>) => RequestResult<SolutionsUninstallSolutionResponses, SolutionsUninstallSolutionErrors, ThrowOnError>;
+/**
+ * List the applications available to the caller, with optional filtering and pagination.
+ */
+declare const applicationsListApplications: <ThrowOnError extends boolean = false>(options?: Options<ApplicationsListApplicationsData, ThrowOnError>) => RequestResult<ApplicationsListApplicationsResponses, ApplicationsListApplicationsErrors, ThrowOnError>;
+/**
+ * Get the full details of a single application identified by its slug.
+ */
+declare const applicationsGetApplication: <ThrowOnError extends boolean = false>(options: Options<ApplicationsGetApplicationData, ThrowOnError>) => RequestResult<ApplicationsGetApplicationResponses, ApplicationsGetApplicationErrors, ThrowOnError>;
+/**
+ * List the connections available to the caller, with optional filtering and pagination.
+ */
+declare const connectionsGetConnections: <ThrowOnError extends boolean = false>(options?: Options<ConnectionsGetConnectionsData, ThrowOnError>) => RequestResult<ConnectionsGetConnectionsResponses, ConnectionsGetConnectionsErrors, ThrowOnError>;
+/**
+ * Create a new connection for the caller.
+ */
+declare const connectionsCreateConnection: <ThrowOnError extends boolean = false>(options: Options<ConnectionsCreateConnectionData, ThrowOnError>) => RequestResult<ConnectionsCreateConnectionResponses, ConnectionsCreateConnectionErrors, ThrowOnError>;
+/**
+ * Delete a connection owned by the caller.
+ */
+declare const connectionsDeleteConnection: <ThrowOnError extends boolean = false>(options: Options<ConnectionsDeleteConnectionData, ThrowOnError>) => RequestResult<ConnectionsDeleteConnectionResponses, ConnectionsDeleteConnectionErrors, ThrowOnError>;
+/**
+ * Get the full details of a single connection identified by its id.
+ */
+declare const connectionsGetConnection: <ThrowOnError extends boolean = false>(options: Options<ConnectionsGetConnectionData, ThrowOnError>) => RequestResult<ConnectionsGetConnectionResponses, ConnectionsGetConnectionErrors, ThrowOnError>;
+/**
+ * Update an existing connection owned by the caller.
+ */
+declare const connectionsUpdateConnection: <ThrowOnError extends boolean = false>(options: Options<ConnectionsUpdateConnectionData, ThrowOnError>) => RequestResult<ConnectionsUpdateConnectionResponses, ConnectionsUpdateConnectionErrors, ThrowOnError>;
+/**
+ * List the caller's default connections, one per application where a default is set.
+ */
+declare const connectionsGetDefaultConnections: <ThrowOnError extends boolean = false>(options?: Options<ConnectionsGetDefaultConnectionsData, ThrowOnError>) => RequestResult<ConnectionsGetDefaultConnectionsResponses, ConnectionsGetDefaultConnectionsErrors, ThrowOnError>;
+/**
+ * Clear the default designation for the given connection.
+ */
+declare const connectionsClearDefaultConnection: <ThrowOnError extends boolean = false>(options: Options<ConnectionsClearDefaultConnectionData, ThrowOnError>) => RequestResult<ConnectionsClearDefaultConnectionResponses, ConnectionsClearDefaultConnectionErrors, ThrowOnError>;
+/**
+ * Set the given connection as the caller's default for its application.
+ */
+declare const connectionsSetDefaultConnection: <ThrowOnError extends boolean = false>(options: Options<ConnectionsSetDefaultConnectionData, ThrowOnError>) => RequestResult<ConnectionsSetDefaultConnectionResponses, ConnectionsSetDefaultConnectionErrors, ThrowOnError>;
+/**
+ * Replace one connection with another across the caller's usages.
+ */
+declare const connectionsReplaceConnection: <ThrowOnError extends boolean = false>(options: Options<ConnectionsReplaceConnectionData, ThrowOnError>) => RequestResult<ConnectionsReplaceConnectionResponses, ConnectionsReplaceConnectionErrors, ThrowOnError>;
+/**
+ * Trigger a refresh of the objects available through the given connection.
+ */
+declare const connectionsRefreshObjects: <ThrowOnError extends boolean = false>(options: Options<ConnectionsRefreshObjectsData, ThrowOnError>) => RequestResult<ConnectionsRefreshObjectsResponses, ConnectionsRefreshObjectsErrors, ThrowOnError>;
+/**
+ * Get the status of the most recent object refresh for the given connection.
+ */
+declare const connectionsGetRefreshStatus: <ThrowOnError extends boolean = false>(options: Options<ConnectionsGetRefreshStatusData, ThrowOnError>) => RequestResult<ConnectionsGetRefreshStatusResponses, ConnectionsGetRefreshStatusErrors, ThrowOnError>;
+/**
+ * Select which objects from the given connection are active for the caller.
+ */
+declare const connectionsSelectObjects: <ThrowOnError extends boolean = false>(options: Options<ConnectionsSelectObjectsData, ThrowOnError>) => RequestResult<ConnectionsSelectObjectsResponses, ConnectionsSelectObjectsErrors, ThrowOnError>;
+/**
+ * List the objects available through the given connection, with optional filtering, sorting, and pagination.
+ */
+declare const connectionsGetConnectionObjects: <ThrowOnError extends boolean = false>(options: Options<ConnectionsGetConnectionObjectsData, ThrowOnError>) => RequestResult<ConnectionsGetConnectionObjectsResponses, ConnectionsGetConnectionObjectsErrors, ThrowOnError>;
+/**
+ * Verify that the given connection is valid and currently usable.
+ */
+declare const connectionsCheckConnection: <ThrowOnError extends boolean = false>(options: Options<ConnectionsCheckConnectionData, ThrowOnError>) => RequestResult<ConnectionsCheckConnectionResponses, ConnectionsCheckConnectionErrors, ThrowOnError>;
+/**
+ * Build an OAuth sign-in URL for an application so the caller can authorize a new connection.
+ */
+declare const connectionsGetSignInUrl: <ThrowOnError extends boolean = false>(options: Options<ConnectionsGetSignInUrlData, ThrowOnError>) => RequestResult<ConnectionsGetSignInUrlResponses, ConnectionsGetSignInUrlErrors, ThrowOnError>;
+/**
+ * Retrieve the access token captured for a previously issued sign-in URL, identified by its state value.
+ */
+declare const connectionsGetAccessToken: <ThrowOnError extends boolean = false>(options: Options<ConnectionsGetAccessTokenData, ThrowOnError>) => RequestResult<ConnectionsGetAccessTokenResponses, ConnectionsGetAccessTokenErrors, ThrowOnError>;
+/**
+ * List the tools available to the caller, with optional filtering and pagination.
+ */
+declare const toolsListTools: <ThrowOnError extends boolean = false>(options?: Options<ToolsListToolsData, ThrowOnError>) => RequestResult<ToolsListToolsResponses, ToolsListToolsErrors, ThrowOnError>;
+/**
+ * Get the full details of a single tool identified by its slug.
+ */
+declare const toolsGetTool: <ThrowOnError extends boolean = false>(options: Options<ToolsGetToolData, ThrowOnError>) => RequestResult<ToolsGetToolResponses, ToolsGetToolErrors, ThrowOnError>;
+/**
+ * Execute a tool. Connection is resolved implicitly from the caller's
+ * account-user, the tool's parent application, and optional toolsetId.
+ * Tool-runtime failures return 200 with isSuccess=false; all other failures
+ * use the standard error envelope.
+ */
+declare const toolsExecuteTool: <ThrowOnError extends boolean = false>(options: Options<ToolsExecuteToolData, ThrowOnError>) => RequestResult<ToolsExecuteToolResponses, ToolsExecuteToolErrors, ThrowOnError>;
+/**
+ * List the toolsets belonging to the caller, with pagination.
+ */
+declare const toolsetsListToolsets: <ThrowOnError extends boolean = false>(options?: Options<ToolsetsListToolsetsData, ThrowOnError>) => RequestResult<ToolsetsListToolsetsResponses, ToolsetsListToolsetsErrors, ThrowOnError>;
+/**
+ * Create a new toolset for the caller.
+ */
+declare const toolsetsCreateToolset: <ThrowOnError extends boolean = false>(options: Options<ToolsetsCreateToolsetData, ThrowOnError>) => RequestResult<ToolsetsCreateToolsetResponses, ToolsetsCreateToolsetErrors, ThrowOnError>;
+/**
+ * Delete a toolset owned by the caller.
+ */
+declare const toolsetsDeleteToolset: <ThrowOnError extends boolean = false>(options: Options<ToolsetsDeleteToolsetData, ThrowOnError>) => RequestResult<ToolsetsDeleteToolsetResponses, ToolsetsDeleteToolsetErrors, ThrowOnError>;
+/**
+ * Get a single toolset owned by the caller, identified by its id.
+ */
+declare const toolsetsGetToolset: <ThrowOnError extends boolean = false>(options: Options<ToolsetsGetToolsetData, ThrowOnError>) => RequestResult<ToolsetsGetToolsetResponses, ToolsetsGetToolsetErrors, ThrowOnError>;
+/**
+ * Update an existing toolset owned by the caller.
+ */
+declare const toolsetsUpdateToolset: <ThrowOnError extends boolean = false>(options: Options<ToolsetsUpdateToolsetData, ThrowOnError>) => RequestResult<ToolsetsUpdateToolsetResponses, ToolsetsUpdateToolsetErrors, ThrowOnError>;
+
+/**
+ * @engini/client — TypeScript REST client for the Engini Public API.
+ *
+ * The code under ./generated is produced by @hey-api/openapi-ts and committed.
+ * DO NOT edit it by hand — regenerate via scripts/regen.sh. This file is the one
+ * hand-written module in the package: it re-exports the generated SDK + types and
+ * adds the Engini-named client factory.
+ */
+
+interface EnginiClientOptions {
+    /** API base URL. Requests append `/v1/...`. */
+    baseUrl: string;
+    /** Optional JWT. When set, bearer-secured operations send `Authorization: Bearer <token>`. */
+    token?: string;
+}
+/**
+ * Create a configured Engini API client to pass to the generated operation
+ * functions, e.g. `await connectionsGetConnections({ client })`.
+ */
+declare function createEnginiClient(options: EnginiClientOptions): Client;
+
+export { type AccessTokenResponse, type ActivityCondition, type ActivitySort, type AppConnectionFieldInputType, type ApplicationAuthMethod, type ApplicationConnectionField, type ApplicationDetailDto, type ApplicationDto, type ApplicationsGetApplicationData, type ApplicationsGetApplicationError, type ApplicationsGetApplicationErrors, type ApplicationsGetApplicationResponse, type ApplicationsGetApplicationResponses, type ApplicationsListApplicationsData, type ApplicationsListApplicationsError, type ApplicationsListApplicationsErrors, type ApplicationsListApplicationsResponse, type ApplicationsListApplicationsResponses, type BuildManifestRequest, type BuildManifestResponse, type BuildManifestTable, type BuildManifestWorkflow, type ClientOptions, type ConnectionInput, type ConnectionObject, type ConnectionPublicDetail, type ConnectionPublicListItem, type ConnectionsCheckConnectionData, type ConnectionsCheckConnectionError, type ConnectionsCheckConnectionErrors, type ConnectionsCheckConnectionResponse, type ConnectionsCheckConnectionResponses, type ConnectionsClearDefaultConnectionData, type ConnectionsClearDefaultConnectionError, type ConnectionsClearDefaultConnectionErrors, type ConnectionsClearDefaultConnectionResponse, type ConnectionsClearDefaultConnectionResponses, type ConnectionsCreateConnectionData, type ConnectionsCreateConnectionError, type ConnectionsCreateConnectionErrors, type ConnectionsCreateConnectionResponse, type ConnectionsCreateConnectionResponses, type ConnectionsDeleteConnectionData, type ConnectionsDeleteConnectionError, type ConnectionsDeleteConnectionErrors, type ConnectionsDeleteConnectionResponse, type ConnectionsDeleteConnectionResponses, type ConnectionsGetAccessTokenData, type ConnectionsGetAccessTokenError, type ConnectionsGetAccessTokenErrors, type ConnectionsGetAccessTokenResponse, type ConnectionsGetAccessTokenResponses, type ConnectionsGetConnectionData, type ConnectionsGetConnectionError, type ConnectionsGetConnectionErrors, type ConnectionsGetConnectionObjectsData, type ConnectionsGetConnectionObjectsError, type ConnectionsGetConnectionObjectsErrors, type ConnectionsGetConnectionObjectsResponse, type ConnectionsGetConnectionObjectsResponses, type ConnectionsGetConnectionResponse, type ConnectionsGetConnectionResponses, type ConnectionsGetConnectionsData, type ConnectionsGetConnectionsError, type ConnectionsGetConnectionsErrors, type ConnectionsGetConnectionsResponse, type ConnectionsGetConnectionsResponses, type ConnectionsGetDefaultConnectionsData, type ConnectionsGetDefaultConnectionsError, type ConnectionsGetDefaultConnectionsErrors, type ConnectionsGetDefaultConnectionsResponse, type ConnectionsGetDefaultConnectionsResponses, type ConnectionsGetRefreshStatusData, type ConnectionsGetRefreshStatusError, type ConnectionsGetRefreshStatusErrors, type ConnectionsGetRefreshStatusResponse, type ConnectionsGetRefreshStatusResponses, type ConnectionsGetSignInUrlData, type ConnectionsGetSignInUrlError, type ConnectionsGetSignInUrlErrors, type ConnectionsGetSignInUrlResponse, type ConnectionsGetSignInUrlResponses, type ConnectionsRefreshObjectsData, type ConnectionsRefreshObjectsError, type ConnectionsRefreshObjectsErrors, type ConnectionsRefreshObjectsResponse, type ConnectionsRefreshObjectsResponses, type ConnectionsReplaceConnectionData, type ConnectionsReplaceConnectionError, type ConnectionsReplaceConnectionErrors, type ConnectionsReplaceConnectionResponse, type ConnectionsReplaceConnectionResponses, type ConnectionsSelectObjectsData, type ConnectionsSelectObjectsError, type ConnectionsSelectObjectsErrors, type ConnectionsSelectObjectsResponse, type ConnectionsSelectObjectsResponses, type ConnectionsSetDefaultConnectionData, type ConnectionsSetDefaultConnectionError, type ConnectionsSetDefaultConnectionErrors, type ConnectionsSetDefaultConnectionResponse, type ConnectionsSetDefaultConnectionResponses, type ConnectionsUpdateConnectionData, type ConnectionsUpdateConnectionError, type ConnectionsUpdateConnectionErrors, type ConnectionsUpdateConnectionResponse, type ConnectionsUpdateConnectionResponses, type CreateConnectionRequest, type CreateSolutionRequest, type CreateToolsetRequest, type CustomConnectionDataItem, type DefaultConnectionDto, type DefaultConnectionsResponse, type EnginiClientOptions, type ErrorDetail, type ErrorResponse, type ExecutionInfo, type InstallSolutionRequest, type InstallSolutionResponse, type InstallationDetailResponse, type InstalledResourceResponse, type ManifestConnection, type ManifestConnectionDefaults, type ManifestTable, type ManifestWorkflow, type Options, type OrderDirection, type PaginatedResponseOfApplicationDto, type PaginatedResponseOfConnectionObject, type PaginatedResponseOfConnectionPublicListItem, type PaginatedResponseOfSolutionResponse, type PaginatedResponseOfToolDto, type PaginatedResponseOfToolsetDto, type ProvisionedResourceInfo, type RefreshStatus, type RefreshStatusResponse, type ReplaceConnectionRequest, type SelectObjectsRequest, type SetDefaultConnectionResponse, type SignInUrlRequest, type SignInUrlResponse, type SolutionAdminWriteResponse, type SolutionDetailResponse, type SolutionInstallationResponse, type SolutionManifest, type SolutionManifestBuildSpec, type SolutionResponse, type SolutionsArchiveSolutionData, type SolutionsArchiveSolutionError, type SolutionsArchiveSolutionErrors, type SolutionsArchiveSolutionResponse, type SolutionsArchiveSolutionResponses, type SolutionsBuildManifestData, type SolutionsBuildManifestError, type SolutionsBuildManifestErrors, type SolutionsBuildManifestResponse, type SolutionsBuildManifestResponses, type SolutionsCreateSolutionData, type SolutionsCreateSolutionError, type SolutionsCreateSolutionErrors, type SolutionsCreateSolutionResponse, type SolutionsCreateSolutionResponses, type SolutionsGetInstallationDetailData, type SolutionsGetInstallationDetailError, type SolutionsGetInstallationDetailErrors, type SolutionsGetInstallationDetailResponse, type SolutionsGetInstallationDetailResponses, type SolutionsGetInstallationResourcesData, type SolutionsGetInstallationResourcesError, type SolutionsGetInstallationResourcesErrors, type SolutionsGetInstallationResourcesResponse, type SolutionsGetInstallationResourcesResponses, type SolutionsGetInstallationsData, type SolutionsGetInstallationsError, type SolutionsGetInstallationsErrors, type SolutionsGetInstallationsResponse, type SolutionsGetInstallationsResponses, type SolutionsGetPublishedSolutionsData, type SolutionsGetPublishedSolutionsError, type SolutionsGetPublishedSolutionsErrors, type SolutionsGetPublishedSolutionsResponse, type SolutionsGetPublishedSolutionsResponses, type SolutionsGetSolutionBySlugData, type SolutionsGetSolutionBySlugError, type SolutionsGetSolutionBySlugErrors, type SolutionsGetSolutionBySlugResponse, type SolutionsGetSolutionBySlugResponses, type SolutionsInstallSolutionData, type SolutionsInstallSolutionError, type SolutionsInstallSolutionErrors, type SolutionsInstallSolutionResponse, type SolutionsInstallSolutionResponses, type SolutionsPublishSolutionData, type SolutionsPublishSolutionError, type SolutionsPublishSolutionErrors, type SolutionsPublishSolutionResponse, type SolutionsPublishSolutionResponses, type SolutionsUninstallSolutionData, type SolutionsUninstallSolutionError, type SolutionsUninstallSolutionErrors, type SolutionsUninstallSolutionResponse, type SolutionsUninstallSolutionResponses, type SolutionsUpdateInstallationData, type SolutionsUpdateInstallationError, type SolutionsUpdateInstallationErrors, type SolutionsUpdateInstallationResponse, type SolutionsUpdateInstallationResponses, type SolutionsUpdateSolutionData, type SolutionsUpdateSolutionError, type SolutionsUpdateSolutionErrors, type SolutionsUpdateSolutionResponse, type SolutionsUpdateSolutionResponses, type TableDefinitionDto, type TableFieldDto, type ToolDetailDto, type ToolDto, type ToolExecuteRequest, type ToolExecuteResponse, type ToolsExecuteToolData, type ToolsExecuteToolError, type ToolsExecuteToolErrors, type ToolsExecuteToolResponse, type ToolsExecuteToolResponses, type ToolsGetToolData, type ToolsGetToolError, type ToolsGetToolErrors, type ToolsGetToolResponse, type ToolsGetToolResponses, type ToolsListToolsData, type ToolsListToolsError, type ToolsListToolsErrors, type ToolsListToolsResponse, type ToolsListToolsResponses, type ToolsetConnectionDto, type ToolsetConnectionRequest, type ToolsetDto, type ToolsetsCreateToolsetData, type ToolsetsCreateToolsetError, type ToolsetsCreateToolsetErrors, type ToolsetsCreateToolsetResponse, type ToolsetsCreateToolsetResponses, type ToolsetsDeleteToolsetData, type ToolsetsDeleteToolsetError, type ToolsetsDeleteToolsetErrors, type ToolsetsDeleteToolsetResponse, type ToolsetsDeleteToolsetResponses, type ToolsetsGetToolsetData, type ToolsetsGetToolsetError, type ToolsetsGetToolsetErrors, type ToolsetsGetToolsetResponse, type ToolsetsGetToolsetResponses, type ToolsetsListToolsetsData, type ToolsetsListToolsetsError, type ToolsetsListToolsetsErrors, type ToolsetsListToolsetsResponse, type ToolsetsListToolsetsResponses, type ToolsetsUpdateToolsetData, type ToolsetsUpdateToolsetError, type ToolsetsUpdateToolsetErrors, type ToolsetsUpdateToolsetResponse, type ToolsetsUpdateToolsetResponses, type UninstallSolutionRequest, type UpdateBlockedResponse, type UpdateBlocker, type UpdateConnectionRequest, type UpdateInstallationRequest, type UpdateInstallationResponse, type UpdateSolutionRequest, type UpdateToolsetRequest, applicationsGetApplication, applicationsListApplications, connectionsCheckConnection, connectionsClearDefaultConnection, connectionsCreateConnection, connectionsDeleteConnection, connectionsGetAccessToken, connectionsGetConnection, connectionsGetConnectionObjects, connectionsGetConnections, connectionsGetDefaultConnections, connectionsGetRefreshStatus, connectionsGetSignInUrl, connectionsRefreshObjects, connectionsReplaceConnection, connectionsSelectObjects, connectionsSetDefaultConnection, connectionsUpdateConnection, createEnginiClient, solutionsArchiveSolution, solutionsBuildManifest, solutionsCreateSolution, solutionsGetInstallationDetail, solutionsGetInstallationResources, solutionsGetInstallations, solutionsGetPublishedSolutions, solutionsGetSolutionBySlug, solutionsInstallSolution, solutionsPublishSolution, solutionsUninstallSolution, solutionsUpdateInstallation, solutionsUpdateSolution, toolsExecuteTool, toolsGetTool, toolsListTools, toolsetsCreateToolset, toolsetsDeleteToolset, toolsetsGetToolset, toolsetsListToolsets, toolsetsUpdateToolset };