@wix/auto_sdk_connectors_connectors 1.0.0

package/build/internal/cjs/meta.d.ts

@@ -0,0 +1,752 @@
+import { GetConnectorRequest as GetConnectorRequest$1, GetConnectorResponse as GetConnectorResponse$1, DeleteConnectorRequest as DeleteConnectorRequest$1, DeleteConnectorResponse as DeleteConnectorResponse$1, QueryConnectorsRequest as QueryConnectorsRequest$1, QueryConnectorsResponse as QueryConnectorsResponse$1, StartConnectRequest as StartConnectRequest$1, StartConnectResponse as StartConnectResponse$1, DispatchRequest as DispatchRequest$1, RawHttpResponse as RawHttpResponse$1, ListMcpToolsRequest as ListMcpToolsRequest$1, ListMcpToolsResponse as ListMcpToolsResponse$1 } from './index.typings.js';
+import '@wix/sdk-types';
+
+/**
+ * Not a taggable product resource: it carries no OAuth credential of its own (that lives on the
+ * shared wix.connectors_access_keys.v1.ConnectorAccessKey), only binding data.
+ */
+interface Connector extends ConnectorRegistrationOneOf {
+    /** Curated owner: the connector app + CONNECTOR_CONFIG component this connection was created against. */
+    predefinedRegistration?: PredefinedRegistration;
+    /** Dynamic owner: the provider registration this connection was created against. */
+    dynamicRegistration?: DynamicRegistration;
+    /**
+     * SDL derives this entity's owner from identity.targetAccountId; do not add account_id.
+     * @format GUID
+     * @readonly
+     */
+    id?: string | null;
+    /**
+     * Optimistic-lock revision assigned by SDL.
+     * @readonly
+     */
+    revision?: string | null;
+    /**
+     * Time at which SDL created the Connector.
+     * @readonly
+     */
+    createdDate?: Date | null;
+    /**
+     * Time at which SDL last updated the Connector.
+     * @readonly
+     */
+    updatedDate?: Date | null;
+    /**
+     * Stable identifier of the connector implementation, for example "github".
+     * @maxLength 80
+     * @immutable
+     */
+    connectorSlug?: string;
+    /**
+     * The provider-side subject this connection is about, and the value inbound webhook deliveries are
+     * attributed by: it must be byte-identical to what a delivery carries at the pointer the connector's
+     * WebhookConfig.provider_tenant_id_json_pointer names. Which value that is follows from where
+     * OAuthConfig.identity_operation.response_id_json_pointer points, so aim that pointer at whatever the
+     * provider's webhooks are about -- usually a workspace, team or installation rather than the individual
+     * user who consented. This PII also participates in the account-local uniqueness constraint.
+     *
+     * For a connector whose WebhookConfig declares verification_source = CONNECTOR_WIDE, a non-empty
+     * provider_tenant_id_json_pointer, and unique_callback_path = false, that byte-identity is a hard
+     * contract, not advice: connectors-webhooks uses this value as the provider tenant identity when it
+     * builds the shared-delivery fan-out route for this connector, so a mismatch means the account's
+     * deliveries verify but resolve no route and are refused. Config validation enforces the
+     * precondition of that contract: such a connector is rejected unless it also names
+     * OAuthConfig.identity_operation.response_id_json_pointer, because a connector that names no
+     * identity pointer produces no external id for a delivery to be matched against. The equivalence
+     * itself stays unvalidated and remains the responsibility of whoever configures the two pointers:
+     * they address different documents -- the provider's identity response and an inbound delivery
+     * body -- so only a live delivery can show that they select the same value.
+     * @internal
+     * @maxLength 200
+     */
+    connectorExternalId?: string;
+    /**
+     * Wix user who consented to this private Connector. Required when exposure is USER.
+     * @internal
+     * @format GUID
+     * @immutable
+     */
+    consentingUserId?: string;
+    /** Whether the Connector is account-owned or restricted to the consenting user. */
+    exposure?: ExposureWithLiterals;
+    /**
+     * Best-effort projection of the shared access key's granted scopes, maintained by consuming
+     * AccessKeyBindingPushed -- see credential_state's comment for the full advisory rule, which applies
+     * identically here. Carried as the GrantedScopes message rather than a bare repeated string so a
+     * provider that never reports scopes (reporting_state NOT_REPORTED) stays distinguishable from one
+     * that explicitly reported an empty set (REPORTED with no scopes); flattening the two would turn an
+     * unknown into a false negative for anyone reading this field. Server-owned: no create or update path
+     * accepts a caller-supplied value for it. The producer only emits AccessKeyBindingPushed on a
+     * credential_state transition, so a scopes-only change at the shared access key (no state transition)
+     * does not reach this field -- it reflects scopes as of the last state transition, not necessarily the
+     * shared key's current scopes.
+     * @internal
+     * @readonly
+     */
+    grantedScopes?: GrantedScopes;
+    /**
+     * Best-effort snapshot of the shared access key's credential_state, maintained by consuming
+     * AccessKeyBindingPushed off connectors-access-keys-store's own state-change events. NEVER a source
+     * of truth and NEVER an authorization input -- under event lag this can read ACTIVE while the key is
+     * REVOKED. It exists only to answer "what should be shown to the user"; every credential-usability
+     * decision (dispatch, revocation, anything that gates behavior) must keep reading
+     * connectors-access-keys-store synchronously. The same rule covers filtering by this field: a query
+     * for credential_state == ACTIVE returns what the platform last believed, never a permission to use
+     * those bindings. UNKNOWN_CREDENTIAL_STATE means no push has ever arrived for the bound access key --
+     * including every row that predates this projection -- and is never a signal of a healthy connection.
+     * Server-owned: no create or update path accepts a caller-supplied value for it. When a push carries
+     * the source event's own timestamp, that timestamp is tracked on the domain row (not exposed on this
+     * contract) and a later push older than the stored value is dropped; a push with no timestamp only
+     * ever initializes a row that has never recorded one, never overwrites an already-timestamped
+     * snapshot.
+     * @readonly
+     */
+    credentialState?: CredentialStateWithLiterals;
+    /**
+     * Deprecated: use registration.predefined_registration.app_id. Retained for callers still on the
+     * flat field. Empty for a dynamic (registration-owned) connector.
+     * @format GUID
+     * @immutable
+     * @deprecated
+     * @replacedBy predefined_registration.app_id
+     * @targetRemovalDate 2027-06-30
+     */
+    appId?: string;
+    /**
+     * Deprecated: use registration.predefined_registration.component_id.
+     * @format GUID
+     * @immutable
+     * @deprecated
+     * @replacedBy predefined_registration.component_id
+     * @targetRemovalDate 2027-06-30
+     */
+    componentId?: string;
+    /** Non-secret discriminant of the owner kind, aligned with the oneof above. */
+    registrationType?: RegistrationTypeWithLiterals;
+    /**
+     * Shared access-key binding identity: the access key this connection is bound to. Within an
+     * account, one binding per scope is allowed, where an ACCOUNT connector uses the empty scope and a
+     * USER connector uses its consenting user -- so a key admits one account-wide binding alongside one
+     * binding per user in that account, and a second binding of the same key in the same scope within
+     * the same account is rejected; the same key may be bound again in a different account, since the
+     * index is scoped by tenant. Required on every connector: it backs the table's sole unique index,
+     * so a connector cannot be stored without one.
+     * @internal
+     * @format GUID
+     * @immutable
+     */
+    accessKeyId?: string | null;
+}
+/** @oneof */
+interface ConnectorRegistrationOneOf {
+    /** Curated owner: the connector app + CONNECTOR_CONFIG component this connection was created against. */
+    predefinedRegistration?: PredefinedRegistration;
+    /** Dynamic owner: the provider registration this connection was created against. */
+    dynamicRegistration?: DynamicRegistration;
+}
+declare enum Exposure {
+    /** The Connector is owned and usable by its account. */
+    ACCOUNT = "ACCOUNT",
+    /** The Connector is restricted to its consenting user. */
+    USER = "USER"
+}
+/** @enumType */
+type ExposureWithLiterals = Exposure | 'ACCOUNT' | 'USER';
+/**
+ * Provider-reported granted scopes, preserving the distinction between a provider that never reports
+ * scopes and one that explicitly reports an empty set.
+ */
+interface GrantedScopes {
+    /** Whether the provider has reported a granted-scopes set for this credential. */
+    reportingState?: ScopeReportingStateWithLiterals;
+    /**
+     * The scopes the provider reported. Meaningful only when reporting_state is REPORTED: an empty list
+     * there means the provider explicitly reported no granted scopes (known-empty), not that reporting is
+     * unknown.
+     * @maxSize 40
+     * @maxLength 70
+     */
+    scopes?: string[];
+}
+declare enum ScopeReportingState {
+    /** The provider has not reported a granted-scopes set for this credential. */
+    NOT_REPORTED = "NOT_REPORTED",
+    /** The provider reported a granted-scopes set, which may itself be empty. */
+    REPORTED = "REPORTED"
+}
+/** @enumType */
+type ScopeReportingStateWithLiterals = ScopeReportingState | 'NOT_REPORTED' | 'REPORTED';
+/** Reused verbatim from wix.connectors.v1. */
+declare enum CredentialState {
+    ACTIVE = "ACTIVE",
+    REVOKED = "REVOKED"
+}
+/** @enumType */
+type CredentialStateWithLiterals = CredentialState | 'ACTIVE' | 'REVOKED';
+/** Curated owner: the connector app plus CONNECTOR_CONFIG component a connection was created against. */
+interface PredefinedRegistration {
+    /**
+     * The connector app that declares the CONNECTOR_CONFIG component.
+     * @format GUID
+     * @immutable
+     */
+    appId?: string;
+    /**
+     * The CONNECTOR_CONFIG component within that app — the stable address for the connector's config.
+     * @format GUID
+     * @immutable
+     */
+    componentId?: string;
+}
+/**
+ * Dynamic owner: the wix.connectors.registry.v1.mcp_server_registration a connection was created
+ * against, for a DCR connector reached by URL. Shared per provider rather than per app/component.
+ */
+interface DynamicRegistration {
+    /**
+     * The provider-registry McpServerRegistration this connection was created against.
+     * @format GUID
+     * @immutable
+     */
+    registrationId?: string;
+}
+/** Which kind of owner this connection belongs to. */
+declare enum RegistrationType {
+    /** Owned by a connector app/component (curated). */
+    PREDEFINED = "PREDEFINED",
+    /** Owned by a provider registration (DCR). */
+    DYNAMIC = "DYNAMIC"
+}
+/** @enumType */
+type RegistrationTypeWithLiterals = RegistrationType | 'PREDEFINED' | 'DYNAMIC';
+interface CreateConnectorRequest {
+    /** Durable OAuth Connector to persist in the target account tenant. */
+    connector?: Connector;
+}
+interface CreateConnectorResponse {
+    /** The persisted Connector. */
+    connector?: Connector;
+}
+interface GetConnectorRequest {
+    /**
+     * ID of the Connector to retrieve.
+     * @format GUID
+     */
+    connectorId: string;
+}
+interface GetConnectorResponse {
+    /** The requested Connector. */
+    connector?: Connector;
+}
+interface DeleteConnectorRequest {
+    /**
+     * ID of the Connector to move to the trash bin.
+     * @format GUID
+     */
+    connectorId: string;
+}
+interface DeleteConnectorResponse {
+}
+interface QueryConnectorsRequest {
+    /** Filter, sort, and cursor paging arguments for Connectors in the target account tenant. */
+    query?: CursorQuery;
+}
+interface CursorQuery extends CursorQueryPagingMethodOneOf {
+    /**
+     * Cursor paging options.
+     *
+     * Learn more about [cursor paging](https://dev.wix.com/docs/rest/articles/getting-started/api-query-language#cursor-paging).
+     */
+    cursorPaging?: CursorPaging;
+    /**
+     * Filter object.
+     *
+     * Learn more about the [filter section](https://dev.wix.com/docs/rest/articles/getting-started/api-query-language#the-filter-section).
+     */
+    filter?: Record<string, any> | null;
+    /**
+     * Sort object.
+     *
+     * Learn more about the [sort section](https://dev.wix.com/docs/rest/articles/getting-started/api-query-language#the-sort-section).
+     * @maxSize 5
+     */
+    sort?: Sorting[];
+}
+/** @oneof */
+interface CursorQueryPagingMethodOneOf {
+    /**
+     * Cursor paging options.
+     *
+     * Learn more about [cursor paging](https://dev.wix.com/docs/rest/articles/getting-started/api-query-language#cursor-paging).
+     */
+    cursorPaging?: CursorPaging;
+}
+interface Sorting {
+    /**
+     * Name of the field to sort by.
+     * @maxLength 512
+     */
+    fieldName?: string;
+    /** Sort order. */
+    order?: SortOrderWithLiterals;
+}
+declare enum SortOrder {
+    ASC = "ASC",
+    DESC = "DESC"
+}
+/** @enumType */
+type SortOrderWithLiterals = SortOrder | 'ASC' | 'DESC';
+interface CursorPaging {
+    /**
+     * Maximum number of items to return in the results.
+     * @max 100
+     */
+    limit?: number | null;
+    /**
+     * Pointer to the next or previous page in the list of results.
+     *
+     * Pass the relevant cursor token from the `pagingMetadata` object in the previous call's response.
+     * Not relevant for the first request.
+     * @maxLength 16000
+     */
+    cursor?: string | null;
+}
+interface QueryConnectorsResponse {
+    /** Connectors from the target account tenant. Protected fields require their own permissions. */
+    connectors?: Connector[];
+    /** Cursor information for the next or previous page. */
+    pagingMetadata?: CursorPagingMetadata;
+}
+interface CursorPagingMetadata {
+    /** Number of items returned in current page. */
+    count?: number | null;
+    /** Cursor strings that point to the next page, previous page, or both. */
+    cursors?: Cursors;
+    /**
+     * Whether there are more pages to retrieve following the current page.
+     *
+     * + `true`: Another page of results can be retrieved.
+     * + `false`: This is the last page.
+     */
+    hasNext?: boolean | null;
+}
+interface Cursors {
+    /**
+     * Cursor string pointing to the next page in the list of results.
+     * @maxLength 16000
+     */
+    next?: string | null;
+    /**
+     * Cursor pointing to the previous page in the list of results.
+     * @maxLength 16000
+     */
+    prev?: string | null;
+}
+interface StartConnectRequest extends StartConnectRequestOwnerOneOf {
+    /** Curated connect: the connector app + CONNECTOR_CONFIG component. */
+    predefinedRegistration?: PredefinedRegistration;
+    /**
+     * Dynamic (DCR) connect: the provider-registry McpServerRegistration reached by URL; the OAuth
+     * config comes from the registration rather than a CONNECTOR_CONFIG component.
+     */
+    dynamicRegistration?: DynamicRegistration;
+    /** Non-secret discriminant of the owner kind, aligned with the oneof above. */
+    registrationType?: StartConnectRequestRegistrationTypeWithLiterals;
+    /**
+     * Deprecated: use owner.predefined_registration.app_id. Retained for callers still on the flat
+     * field until they migrate to the owner oneof. Not GUID-typed: that format rejects the empty
+     * default a oneof-owner request carries, so this optional field only caps length.
+     * @maxLength 80
+     * @deprecated
+     * @replacedBy predefined_registration.app_id
+     * @targetRemovalDate 2027-06-30
+     */
+    appId?: string;
+    /**
+     * Deprecated: use owner.predefined_registration.component_id.
+     * @maxLength 80
+     * @deprecated
+     * @replacedBy predefined_registration.component_id
+     * @targetRemovalDate 2027-06-30
+     */
+    componentId?: string;
+    /**
+     * Requested exposure of the Connector this connect will produce. UNKNOWN_EXPOSURE is treated as
+     * ACCOUNT. USER requires an initiating Wix user identity on the call — its id is recorded as the
+     * Connector's consenting_user_id and the connection is then visible only to that user.
+     */
+    exposure?: ExposureWithLiterals;
+    /**
+     * Optional Wix URL to return the browser to after connect completes. Must pass the Wix-domain
+     * allowlist (validated server-side at GenerateAuthorizationUrl). When omitted, the fixed landing
+     * page is used. Carried through the handshake; the same URL is used for both success and error
+     * landings (with ?error= on failure). Not WEB_URL-typed: that format rejects the empty default, so
+     * this optional field only caps length here — the server-side allowlist is the real URL gate.
+     * @maxLength 2048
+     */
+    returnUrl?: string;
+}
+/** @oneof */
+interface StartConnectRequestOwnerOneOf {
+    /** Curated connect: the connector app + CONNECTOR_CONFIG component. */
+    predefinedRegistration?: PredefinedRegistration;
+    /**
+     * Dynamic (DCR) connect: the provider-registry McpServerRegistration reached by URL; the OAuth
+     * config comes from the registration rather than a CONNECTOR_CONFIG component.
+     */
+    dynamicRegistration?: DynamicRegistration;
+}
+/** Which kind of owner this connect targets. */
+declare enum StartConnectRequestRegistrationType {
+    /** Curated owner (app_id + component_id). */
+    PREDEFINED = "PREDEFINED",
+    /** Dynamic (DCR) owner (registration_id). */
+    DYNAMIC = "DYNAMIC"
+}
+/** @enumType */
+type StartConnectRequestRegistrationTypeWithLiterals = StartConnectRequestRegistrationType | 'PREDEFINED' | 'DYNAMIC';
+interface StartConnectResponse extends StartConnectResponseNextActionOneOf {
+    /** Redirect the caller's browser to complete the connect. */
+    redirect?: Redirect;
+    /** Nothing left to do — the connect is already finished. */
+    completed?: Completed;
+    /**
+     * Deprecated: read `next_action.redirect.url` instead. Still populated whenever the next action IS
+     * a redirect, so callers that have not migrated keep working; it is simply unable to express any
+     * other outcome, which is why it is being replaced rather than extended.
+     * @format WEB_URL
+     * @deprecated
+     * @replacedBy next_action.redirect.url
+     * @targetRemovalDate 2027-06-30
+     */
+    authorizationUrl?: string;
+}
+/** @oneof */
+interface StartConnectResponseNextActionOneOf {
+    /** Redirect the caller's browser to complete the connect. */
+    redirect?: Redirect;
+    /** Nothing left to do — the connect is already finished. */
+    completed?: Completed;
+}
+/** Redirects the caller's browser to a provider authorization URL. */
+interface Redirect {
+    /**
+     * Provider authorization URL to redirect the user's browser to.
+     * @format WEB_URL
+     */
+    url?: string;
+}
+/**
+ * The connect is already finished and the Connector exists; no user interaction happened or is needed.
+ * Returned for a provider that requires no authorization at all, where there is no authorization URL
+ * to visit and so no callback to return through.
+ */
+interface Completed {
+    /**
+     * Id of the access key the resulting Connector is bound to.
+     * @format GUID
+     */
+    accessKeyId?: string;
+}
+interface DomainEvent extends DomainEventBodyOneOf {
+    createdEvent?: EntityCreatedEvent;
+    updatedEvent?: EntityUpdatedEvent;
+    deletedEvent?: EntityDeletedEvent;
+    actionEvent?: ActionEvent;
+    /** Event ID. With this ID you can easily spot duplicated events and ignore them. */
+    id?: string;
+    /**
+     * Fully Qualified Domain Name of an entity. This is a unique identifier assigned to the API main business entities.
+     * For example, `wix.stores.catalog.product`, `wix.bookings.session`, `wix.payments.transaction`.
+     */
+    entityFqdn?: string;
+    /**
+     * Event action name, placed at the top level to make it easier for users to dispatch messages.
+     * For example: `created`/`updated`/`deleted`/`started`/`completed`/`email_opened`.
+     */
+    slug?: string;
+    /** ID of the entity associated with the event. */
+    entityId?: string;
+    /** Event timestamp in [ISO-8601](https://en.wikipedia.org/wiki/ISO_8601) format and UTC time. For example, `2020-04-26T13:57:50.699Z`. */
+    eventTime?: Date | null;
+    /**
+     * Whether the event was triggered as a result of a privacy regulation application
+     * (for example, GDPR).
+     */
+    triggeredByAnonymizeRequest?: boolean | null;
+    /** If present, indicates the action that triggered the event. */
+    originatedFrom?: string | null;
+    /**
+     * A sequence number that indicates the order of updates to an entity. For example, if an entity was updated at `16:00` and then again at `16:01`, the second update will always have a higher sequence number.
+     * You can use this number to make sure you're handling updates in the right order. Just save the latest sequence number on your end and compare it to the one in each new message. If the new message has an older (lower) number, you can safely ignore it.
+     */
+    entityEventSequence?: string | null;
+}
+/** @oneof */
+interface DomainEventBodyOneOf {
+    createdEvent?: EntityCreatedEvent;
+    updatedEvent?: EntityUpdatedEvent;
+    deletedEvent?: EntityDeletedEvent;
+    actionEvent?: ActionEvent;
+}
+interface EntityCreatedEvent {
+    entityAsJson?: string;
+    /**
+     * Indicates the event was triggered by a restore-from-trashbin operation for a previously deleted entity
+     * @internal
+     */
+    triggeredByUndelete?: boolean | null;
+    /** Indicates the event was triggered by a restore-from-trashbin operation for a previously deleted entity */
+    restoreInfo?: RestoreInfo;
+    /**
+     * Optional domain-specific metadata defined by the API owner, encoded as JSON.
+     * @internal
+     */
+    additionalMetadataAsJson?: string | null;
+}
+interface RestoreInfo {
+    deletedDate?: Date | null;
+}
+interface EntityUpdatedEvent {
+    /**
+     * Since platformized APIs only expose PATCH and not PUT we can't assume that the fields sent from the client are the actual diff.
+     * This means that to generate a list of changed fields (as opposed to sent fields) one needs to traverse both objects.
+     * We don't want to impose this on all developers and so we leave this traversal to the notification recipients which need it.
+     */
+    currentEntityAsJson?: string;
+    /**
+     * This field is currently part of the of the EntityUpdatedEvent msg, but scala/node libraries which implements the domain events standard
+     * wont populate it / have any reference to it in the API.
+     * The main reason for it is that fetching the old entity from the DB will have a performance hit on an update operation so unless truly needed,
+     * the developer should send only the new (current) entity.
+     * An additional reason is not wanting to send this additional entity over the wire (kafka) since in some cases it can be really big
+     * Developers that must reflect the old entity will have to implement their own domain event sender mechanism which will follow the DomainEvent proto message.
+     * @internal
+     * @deprecated
+     */
+    previousEntityAsJson?: string | null;
+    /**
+     * Map of fully qualified field paths to their previous values for fields that changed.
+     * For more details please see [AIP](https://dev.wix.com/docs/rnd-general/articles/p13n-guidelines-aips/guidance-aips/design-patterns/7016-events#modified-fields-format)
+     * @internal
+     */
+    modifiedFields?: Record<string, any>;
+    /**
+     * Optional domain-specific metadata defined by the API owner, encoded as JSON.
+     * @internal
+     */
+    additionalMetadataAsJson?: string | null;
+}
+interface EntityDeletedEvent {
+    /**
+     * Indicates if the entity is sent to trash-bin. only available when trash-bin is enabled
+     * @internal
+     */
+    movedToTrash?: boolean | null;
+    /** Entity that was deleted. */
+    deletedEntityAsJson?: string | null;
+    /**
+     * Optional domain-specific metadata defined by the API owner, encoded as JSON.
+     * @internal
+     */
+    additionalMetadataAsJson?: string | null;
+}
+interface ActionEvent {
+    bodyAsJson?: string;
+}
+interface Empty {
+}
+interface MessageEnvelope {
+    /**
+     * App instance ID.
+     * @format GUID
+     */
+    instanceId?: string | null;
+    /**
+     * Event type.
+     * @maxLength 150
+     */
+    eventType?: string;
+    /** The identification type and identity data. */
+    identity?: IdentificationData;
+    /** Stringify payload. */
+    data?: string;
+    /** Details related to the account */
+    accountInfo?: AccountInfo;
+}
+interface IdentificationData extends IdentificationDataIdOneOf {
+    /**
+     * ID of a site visitor that has not logged in to the site.
+     * @format GUID
+     */
+    anonymousVisitorId?: string;
+    /**
+     * ID of a site visitor that has logged in to the site.
+     * @format GUID
+     */
+    memberId?: string;
+    /**
+     * ID of a Wix user (site owner, contributor, etc.).
+     * @format GUID
+     */
+    wixUserId?: string;
+    /**
+     * ID of an app.
+     * @format GUID
+     */
+    appId?: string;
+    /** @readonly */
+    identityType?: WebhookIdentityTypeWithLiterals;
+}
+/** @oneof */
+interface IdentificationDataIdOneOf {
+    /**
+     * ID of a site visitor that has not logged in to the site.
+     * @format GUID
+     */
+    anonymousVisitorId?: string;
+    /**
+     * ID of a site visitor that has logged in to the site.
+     * @format GUID
+     */
+    memberId?: string;
+    /**
+     * ID of a Wix user (site owner, contributor, etc.).
+     * @format GUID
+     */
+    wixUserId?: string;
+    /**
+     * ID of an app.
+     * @format GUID
+     */
+    appId?: string;
+}
+declare enum WebhookIdentityType {
+    UNKNOWN = "UNKNOWN",
+    ANONYMOUS_VISITOR = "ANONYMOUS_VISITOR",
+    MEMBER = "MEMBER",
+    WIX_USER = "WIX_USER",
+    APP = "APP"
+}
+/** @enumType */
+type WebhookIdentityTypeWithLiterals = WebhookIdentityType | 'UNKNOWN' | 'ANONYMOUS_VISITOR' | 'MEMBER' | 'WIX_USER' | 'APP';
+interface AccountInfo {
+    /**
+     * ID of the Wix account associated with the event.
+     * @format GUID
+     */
+    accountId?: string | null;
+    /**
+     * ID of the parent Wix account. Only included when accountId belongs to a child account.
+     * @format GUID
+     */
+    parentAccountId?: string | null;
+    /**
+     * ID of the Wix site associated with the event. Only included when the event is tied to a specific site.
+     * @format GUID
+     */
+    siteId?: string | null;
+}
+interface DispatchRequest {
+    /**
+     * ID of the Connector to authorize in the caller's target account.
+     * @format GUID
+     */
+    connectorId: string;
+    /** Raw provider request. Callers must not include credentials; Wix injects them at dispatch. */
+    providerRequest: RawHttpRequest;
+    /**
+     * Optional caller-supplied key making a retry of this dispatch safe: the same key on the same
+     * connector will not produce a second provider attempt through Wix. Scoped to the connector, so
+     * callers need only make it unique per connector. Guarantees at-most-once ATTEMPT by Wix — it
+     * cannot guarantee the provider applied the effect at most once when an attempt's outcome is
+     * unknown (timeout, connection reset). For that, include the provider's own idempotency header in
+     * provider_request. A repeated key fails with a duplicate-dispatch error rather than replaying the
+     * original response, which Wix does not retain; callers needing it must store it themselves.
+     * @maxLength 128
+     */
+    idempotencyKey?: string;
+}
+interface RawHttpRequest {
+    body?: Uint8Array;
+    pathParams?: PathParametersEntry[];
+    queryParams?: QueryParametersEntry[];
+    headers?: HeadersEntry[];
+    method?: string;
+    rawPath?: string;
+    rawQuery?: string;
+}
+interface PathParametersEntry {
+    key?: string;
+    value?: string;
+}
+interface QueryParametersEntry {
+    key?: string;
+    value?: string;
+}
+interface HeadersEntry {
+    key?: string;
+    value?: string;
+}
+interface RawHttpResponse {
+    body?: Uint8Array;
+    statusCode?: number | null;
+    headers?: HeadersEntry[];
+}
+interface ListMcpToolsRequest {
+    /**
+     * ID of the Connector whose callable MCP tools are requested.
+     * @format GUID
+     */
+    connectorId: string;
+}
+interface ListMcpToolsResponse {
+    /**
+     * The server's advertised tools filtered by the connector's allowlist. Capped to match mcp_config.allowed_tools' own maximum; the runtime
+     * rejects a provider advertisement it cannot fit rather than returning an unbounded payload.
+     * @maxSize 200
+     */
+    tools?: McpTool[];
+}
+/** One MCP tool as advertised by the connector's MCP server. */
+interface McpTool {
+    /**
+     * Tool name, exactly as the server advertises it.
+     * @maxLength 128
+     */
+    name?: string;
+    /**
+     * Human- and model-readable description of what the tool does, as provided by the server.
+     * @maxLength 10000
+     */
+    description?: string;
+    /** JSON Schema of the tool's arguments, as provided by the server. */
+    inputSchema?: Record<string, any> | null;
+}
+
+type __PublicMethodMetaInfo<K = string, M = unknown, T = unknown, S = unknown, Q = unknown, R = unknown> = {
+    getUrl: (context: any) => string;
+    httpMethod: K;
+    path: string;
+    pathParams: M;
+    __requestType: T;
+    __originalRequestType: S;
+    __responseType: Q;
+    __originalResponseType: R;
+};
+declare function getConnector(): __PublicMethodMetaInfo<'GET', {
+    connectorId: string;
+}, GetConnectorRequest$1, GetConnectorRequest, GetConnectorResponse$1, GetConnectorResponse>;
+declare function deleteConnector(): __PublicMethodMetaInfo<'DELETE', {
+    connectorId: string;
+}, DeleteConnectorRequest$1, DeleteConnectorRequest, DeleteConnectorResponse$1, DeleteConnectorResponse>;
+declare function queryConnectors(): __PublicMethodMetaInfo<'POST', {}, QueryConnectorsRequest$1, QueryConnectorsRequest, QueryConnectorsResponse$1, QueryConnectorsResponse>;
+declare function startConnect(): __PublicMethodMetaInfo<'POST', {}, StartConnectRequest$1, StartConnectRequest, StartConnectResponse$1, StartConnectResponse>;
+declare function dispatcherDispatch(): __PublicMethodMetaInfo<'POST', {
+    connectorId: string;
+}, DispatchRequest$1, DispatchRequest, RawHttpResponse$1, RawHttpResponse>;
+declare function listMcpTools(): __PublicMethodMetaInfo<'GET', {
+    connectorId: string;
+}, ListMcpToolsRequest$1, ListMcpToolsRequest, ListMcpToolsResponse$1, ListMcpToolsResponse>;
+
+export { type AccountInfo as AccountInfoOriginal, type ActionEvent as ActionEventOriginal, type Completed as CompletedOriginal, type Connector as ConnectorOriginal, type ConnectorRegistrationOneOf as ConnectorRegistrationOneOfOriginal, type CreateConnectorRequest as CreateConnectorRequestOriginal, type CreateConnectorResponse as CreateConnectorResponseOriginal, CredentialState as CredentialStateOriginal, type CredentialStateWithLiterals as CredentialStateWithLiteralsOriginal, type CursorPagingMetadata as CursorPagingMetadataOriginal, type CursorPaging as CursorPagingOriginal, type CursorQuery as CursorQueryOriginal, type CursorQueryPagingMethodOneOf as CursorQueryPagingMethodOneOfOriginal, type Cursors as CursorsOriginal, type DeleteConnectorRequest as DeleteConnectorRequestOriginal, type DeleteConnectorResponse as DeleteConnectorResponseOriginal, type DispatchRequest as DispatchRequestOriginal, type DomainEventBodyOneOf as DomainEventBodyOneOfOriginal, type DomainEvent as DomainEventOriginal, type DynamicRegistration as DynamicRegistrationOriginal, type Empty as EmptyOriginal, type EntityCreatedEvent as EntityCreatedEventOriginal, type EntityDeletedEvent as EntityDeletedEventOriginal, type EntityUpdatedEvent as EntityUpdatedEventOriginal, Exposure as ExposureOriginal, type ExposureWithLiterals as ExposureWithLiteralsOriginal, type GetConnectorRequest as GetConnectorRequestOriginal, type GetConnectorResponse as GetConnectorResponseOriginal, type GrantedScopes as GrantedScopesOriginal, type HeadersEntry as HeadersEntryOriginal, type IdentificationDataIdOneOf as IdentificationDataIdOneOfOriginal, type IdentificationData as IdentificationDataOriginal, type ListMcpToolsRequest as ListMcpToolsRequestOriginal, type ListMcpToolsResponse as ListMcpToolsResponseOriginal, type McpTool as McpToolOriginal, type MessageEnvelope as MessageEnvelopeOriginal, type PathParametersEntry as PathParametersEntryOriginal, type PredefinedRegistration as PredefinedRegistrationOriginal, type QueryConnectorsRequest as QueryConnectorsRequestOriginal, type QueryConnectorsResponse as QueryConnectorsResponseOriginal, type QueryParametersEntry as QueryParametersEntryOriginal, type RawHttpRequest as RawHttpRequestOriginal, type RawHttpResponse as RawHttpResponseOriginal, type Redirect as RedirectOriginal, RegistrationType as RegistrationTypeOriginal, type RegistrationTypeWithLiterals as RegistrationTypeWithLiteralsOriginal, type RestoreInfo as RestoreInfoOriginal, ScopeReportingState as ScopeReportingStateOriginal, type ScopeReportingStateWithLiterals as ScopeReportingStateWithLiteralsOriginal, SortOrder as SortOrderOriginal, type SortOrderWithLiterals as SortOrderWithLiteralsOriginal, type Sorting as SortingOriginal, type StartConnectRequest as StartConnectRequestOriginal, type StartConnectRequestOwnerOneOf as StartConnectRequestOwnerOneOfOriginal, StartConnectRequestRegistrationType as StartConnectRequestRegistrationTypeOriginal, type StartConnectRequestRegistrationTypeWithLiterals as StartConnectRequestRegistrationTypeWithLiteralsOriginal, type StartConnectResponseNextActionOneOf as StartConnectResponseNextActionOneOfOriginal, type StartConnectResponse as StartConnectResponseOriginal, WebhookIdentityType as WebhookIdentityTypeOriginal, type WebhookIdentityTypeWithLiterals as WebhookIdentityTypeWithLiteralsOriginal, type __PublicMethodMetaInfo, deleteConnector, dispatcherDispatch, getConnector, listMcpTools, queryConnectors, startConnect };