@wix/auto_sdk_connectors_connectors 1.0.0

package/build/internal/es/index.d.mts

@@ -0,0 +1,89 @@
+import { HttpClient, NonNullablePaths, MaybeContext, BuildRESTFunction } from '@wix/sdk-types';
+import { Connector, StartConnectOptions, StartConnectResponse, RawHttpRequest, DispatcherDispatchOptions, RawHttpResponse, ListMcpToolsResponse, ConnectorsQueryBuilder, ConnectorQuery, typedQueryConnectors } from './index.typings.mjs';
+export { AccountInfo, ActionEvent, CommonQueryWithEntityContext, Completed, ConnectorQuerySpec, ConnectorRegistrationOneOf, ConnectorsQueryResult, CreateConnectorRequest, CreateConnectorResponse, CredentialState, CredentialStateWithLiterals, CursorPaging, CursorPagingMetadata, CursorQuery, CursorQueryPagingMethodOneOf, Cursors, DeleteConnectorRequest, DeleteConnectorResponse, DispatchRequest, DomainEvent, DomainEventBodyOneOf, DynamicRegistration, Empty, EntityCreatedEvent, EntityDeletedEvent, EntityUpdatedEvent, Exposure, ExposureWithLiterals, GetConnectorRequest, GetConnectorResponse, GrantedScopes, HeadersEntry, IdentificationData, IdentificationDataIdOneOf, ListMcpToolsRequest, McpTool, MessageEnvelope, PathParametersEntry, PredefinedRegistration, QueryConnectorsRequest, QueryConnectorsResponse, QueryParametersEntry, Redirect, RegistrationType, RegistrationTypeWithLiterals, RestoreInfo, ScopeReportingState, ScopeReportingStateWithLiterals, SortOrder, SortOrderWithLiterals, Sorting, StartConnectOptionsOwnerOneOf, StartConnectRequest, StartConnectRequestOwnerOneOf, StartConnectRequestRegistrationType, StartConnectRequestRegistrationTypeWithLiterals, StartConnectResponseNextActionOneOf, WebhookIdentityType, WebhookIdentityTypeWithLiterals, utils } from './index.typings.mjs';
+
+/** @internal */
+declare function getConnector$1(httpClient: HttpClient): GetConnectorSignature;
+interface GetConnectorSignature {
+    /**
+     * Retrieves one Connector in the caller's target account tenant. USER Connectors are visible
+     * to their consenting user or to a server-signed app authorized by get_connector; ACCOUNT
+     * Connectors are visible to authorized account callers.
+     * @param - ID of the Connector to retrieve.
+     * @returns The requested Connector.
+     */
+    (connectorId: string): Promise<NonNullablePaths<Connector, `predefinedRegistration.appId` | `predefinedRegistration.componentId` | `dynamicRegistration.registrationId` | `connectorSlug` | `exposure` | `credentialState` | `appId` | `componentId` | `registrationType`, 3>>;
+}
+/** @internal */
+declare function deleteConnector$1(httpClient: HttpClient): DeleteConnectorSignature;
+interface DeleteConnectorSignature {
+    /**
+     * Moves a Connector to the trash bin, disconnecting it from future use.
+     *
+     * Removing the binding does not revoke the provider authorization: the access key is shared, and other
+     * account or site bindings may still depend on it. Reclaiming an unreferenced access key is the
+     * access key owner's job, not this method's.
+     * @param - ID of the Connector to move to the trash bin.
+     */
+    (connectorId: string): Promise<void>;
+}
+declare function startConnect$1(httpClient: HttpClient): StartConnectSignature;
+interface StartConnectSignature {
+    /**
+     * Starts an OAuth connect for a connector component, under the caller's identity.targetAccountId.
+     * Asks oauth-handler to generate the provider authorization URL: it mints an unguessable, one-time
+     * state, caches the trusted completion context (PKCE verifier when configured) in WixCache with a
+     * short TTL, and returns the URL to redirect the user's browser to. Does not create a Connector —
+     * a Connector exists only after the OAuth callback completes. Does not install an app or call
+     * any app-installation API.
+     */
+    (options?: StartConnectOptions): Promise<NonNullablePaths<StartConnectResponse, `redirect.url` | `completed.accessKeyId` | `authorizationUrl`, 3>>;
+}
+/** @internal */
+declare function dispatcherDispatch$1(httpClient: HttpClient): DispatcherDispatchSignature;
+interface DispatcherDispatchSignature {
+    /**
+     * Dispatches one provider request using credentials owned and injected by Wix.
+     *
+     * The provider's answer is returned as-is, including a rejection. A rejection carrying
+     * `WWW-Authenticate: Bearer error="insufficient_scope"` (RFC 6750 §3) means the credential is
+     * valid but the granted permissions do not cover the request: Wix reports it as a dispatch
+     * rejection with reason `insufficient_scope`, so a permission gap affecting a whole connector
+     * fleet is visible rather than showing up as an unexplained 403. Wix does not retry or re-mint
+     * the credential in that case, because the same grant would be issued again. The remedy is a
+     * full reconnect of the affected connector — see ConnectorConfig.OAuthConfig.default_scopes.
+     * @param - ID of the Connector to authorize in the caller's target account.
+     * @param - Raw provider request. Callers must not include credentials; Wix injects them at dispatch.
+     */
+    (connectorId: string, providerRequest: RawHttpRequest, options?: DispatcherDispatchOptions): Promise<NonNullablePaths<RawHttpResponse, `body` | `headers` | `headers.${number}.key` | `headers.${number}.value`, 4>>;
+}
+/** @internal */
+declare function listMcpTools$1(httpClient: HttpClient): ListMcpToolsSignature;
+interface ListMcpToolsSignature {
+    /**
+     * Deprecated: the MCP surface moved to connectors-mcp-proxy — speak MCP to it directly
+     * (its tools/list answer is filtered by the connector's allowlist the same way). This RPC
+     * keeps working for existing callers: the server's advertised tools/list filtered by
+     * ConnectorConfig.mcp_config.allowed_tools.
+     * @param - ID of the Connector whose callable MCP tools are requested.
+     * @deprecated
+     */
+    (connectorId: string): Promise<NonNullablePaths<ListMcpToolsResponse, `tools` | `tools.${number}.name` | `tools.${number}.description`, 4>>;
+}
+
+declare function customQueryConnectors(httpClient: HttpClient): {
+    (): ConnectorsQueryBuilder;
+    (query: ConnectorQuery): ReturnType<typeof typedQueryConnectors>;
+};
+/** @internal */
+declare const getConnector: MaybeContext<BuildRESTFunction<typeof getConnector$1> & typeof getConnector$1>;
+/** @internal */
+declare const deleteConnector: MaybeContext<BuildRESTFunction<typeof deleteConnector$1> & typeof deleteConnector$1>;
+declare const startConnect: MaybeContext<BuildRESTFunction<typeof startConnect$1> & typeof startConnect$1>;
+/** @internal */
+declare const dispatcherDispatch: MaybeContext<BuildRESTFunction<typeof dispatcherDispatch$1> & typeof dispatcherDispatch$1>;
+/** @internal */
+declare const listMcpTools: MaybeContext<BuildRESTFunction<typeof listMcpTools$1> & typeof listMcpTools$1>;
+declare const queryConnectors: MaybeContext<BuildRESTFunction<typeof customQueryConnectors> & typeof customQueryConnectors>;
+
+export { Connector, ConnectorQuery, ConnectorsQueryBuilder, DispatcherDispatchOptions, ListMcpToolsResponse, RawHttpRequest, RawHttpResponse, StartConnectOptions, StartConnectResponse, deleteConnector, dispatcherDispatch, getConnector, listMcpTools, queryConnectors, startConnect };