@wordrhyme/plugin 0.1.0-alpha.10

package/dist/index.d.ts

@@ -0,0 +1,724 @@
+import { a as PluginContext, d as PluginLogger, e as WebPluginSiteInfo } from './types-BJo3_91V.js';
+export { A as ActionContractMeta, f as ActionDescriptor, g as ActionInvokeRequest, h as AgentToolDescriptor, i as AiAliasDescriptor, j as AiBudget, k as AiModelCatalog, l as AiModelHint, m as AiModelListRequest, n as AiModelOption, o as AiObjectRequest, p as AiObjectResult, q as AiObjectSchema, r as AiRuntimeHandler, s as AiRuntimeHost, t as AiRuntimeInvocation, u as AiStreamEvent, v as AiTextRequest, w as AiTextResult, x as AiUsage, y as AiUsageAuthorization, z as AiUsageObservation, B as ApiPayload, E as EAuthModel, C as EAuthProvider, D as EAuthRefreshInput, F as EAuthRefreshResult, G as EAuthStatus, I as EAuthTokenResult, J as EAuthUpsertInput, K as EAuthUse, L as HookAbortError, H as HookContext, M as HookEmitOptions, b as HookHandlerOptions, N as HookPriority, c as HookTransaction, O as MARKETPLACE_PUBLISH_AUTH_METHODS, Q as MarketplaceAttestationTargetV1, R as MarketplaceExecutionErrorCode, S as MarketplaceExecutionFailureCode, T as MarketplaceOrganizationExecutionV1, U as MarketplacePlatformReadAction, V as MarketplacePublishActor, X as MarketplacePublishAuthMethod, Y as MarketplacePublisherAction, Z as MarketplaceRegistrySigningCapability, _ as OpaquePublisherCandidateV1, $ as PluginActionInvokerCapability, a0 as PluginAgentCapability, a1 as PluginAiCapability, a2 as PluginAiRuntimeCapability, a3 as PluginApisCapability, a4 as PluginArtifactCapability, a5 as PluginAssetCapability, a6 as PluginAssetCreateOptions, a7 as PluginAssetInfo, a8 as PluginAssetQuery, a9 as PluginAssetUpdateData, aa as PluginAssetVariant, ab as PluginCurrencyCapability, ac as PluginEAuthCapability, ad as PluginEntityExtensionCapability, ae as PluginEntityExtensionFilter, af as PluginFileCapability, ag as PluginFileInfo, ah as PluginFileQuery, ai as PluginFileUploadInput, aj as PluginHookCapability, ak as PluginJobOptions, al as PluginJobStatus, am as PluginMediaCapability, P as PluginMediaInfo, an as PluginMediaQuery, ao as PluginMediaUpdateData, ap as PluginMediaUploadInput, aq as PluginMediaVariant, ar as PluginMetricsAllowedLabels, as as PluginMetricsCapability, at as PluginNotificationActor, au as PluginNotificationCapability, av as PluginNotificationChannel, aw as PluginNotificationEvent, ax as PluginNotificationInput, ay as PluginNotificationResult, az as PluginNotificationSendParams, aA as PluginNotificationSendResult, aB as PluginNotificationTarget, aC as PluginNotificationTemplate, aD as PluginOrganizationMembersCapability, aE as PluginOrganizationProvisioningCapability, aF as PluginPaginatedResult, aG as PluginPermissionCapability, aH as PluginPermissionCheckContext, aI as PluginPermissionDef, aJ as PluginQueueCapability, aK as PluginScopedDb, aL as PluginSettingEntry, aM as PluginSettingOptions, aN as PluginSettingsCapability, aO as PluginStorageCapability, aP as PluginStorageProvider, aQ as PluginStorageProviderConfig, aR as PluginStorageProviderInfo, aS as PluginStorageUploadInput, aT as PluginStorageUploadResult, aU as PluginTraceCapability, aV as PluginUsageCapability, aW as PluginWebCapability, aX as ReadonlyPluginScopedDb, aY as WebJsonPrimitive, aZ as WebJsonValue, a_ as WebPluginDocumentMode, a$ as WebPluginHead, b0 as WebPluginHeadLink, b1 as WebPluginPresentationSurfaceResult, b2 as WebPluginRouteHandler, b3 as WebPluginRouteRequest, b4 as WebPluginRouteResult, b5 as WebPluginTenantInfo, b6 as WebPresentationAdapterClientDescriptor, b7 as WebResolvedPresentationAdapter, b8 as WebResolvedSitePresentation, b9 as WebResolvedSiteShell, ba as WebResolvedThemeAsset, bb as WebSerializableGlobalizationState, bc as WebSlotExtensionQuery, bd as WebSlotQueryResult, W as WebSlotRemoteExtension, be as WebSlotRenderMode, bf as WebSlotRenderOptions, bg as WebSlotRenderRequest, bh as WebSlotRenderResult, bi as WebSlotRenderer, bj as WebThemeShellClientDescriptor, bk as WebThemeShellDocumentModel, bl as WebThemeShellRenderResult, bm as WebThemeShellRenderer, bn as WebThemeShellRouteModel } from './types-BJo3_91V.js';
+import { z } from 'zod';
+import { Translator } from './globalization.js';
+export { CurrencyInfo, DEFAULT_CURRENCY, FormatPriceOptions, GlobalizationState, I18nTextField, LanguageInfo, PriceFormatter, TextDirection, TranslationMessages, bankersRound, buildGlobalizationUrl, convertCurrency, createPriceFormatter, createTranslator, findCurrency, formatCurrencyAmount, formatPrice, fromCents, getBaseCurrency, getI18nText, getTextDirection, normalizeCurrencies, normalizeCurrencyInfo, resolveCurrencyInfo, toCents, withGlobalizationHelpers } from './globalization.js';
+export { DEFAULT_LOCALE, canonicalizeLocale, isLocale, normalizeLocale } from './locale.js';
+export { CLIENT_TIME_ZONE_COOKIE, CLIENT_TIME_ZONE_HEADER, DEFAULT_TIME_ZONE, DateFilterInput, DateFilterRange, DateRangeResolver, FormatDateTimeOptions, canonicalizeTimeZone, formatDateTime, getClientTimeZone, getSupportedTimeZones, isValidTimeZone, normalizeTimeZone, resolveDateFilterRange, toDateTimeLocal, toUtcDateTime, toUtcDayRange } from './time.js';
+import { P as PluginManifest } from './manifest-CTFX-h0w.js';
+export { A as AdminTour, b as AdminTourPlacement, c as AdminTourStep, d as AggregationStrategy, e as AutoCrudAction, f as AutoCrudActionZone, g as AutoCrudActions, h as EntityExtension, i as EntityExtensionCrudConfig, a as EntityExtensionField, E as EntityExtensionFieldType, j as EntityExtensionSlot, k as EntityExtensionUse, l as PluginCapabilities, m as PluginNotificationType, n as PluginStatus, W as WebDesignAction, o as WebDesignBlock, p as WebDesignDataSource, q as WebDesignSlot, r as WebDesignSurface, s as WebDesignTemplate, t as WebExtension, u as WebExtensionQuery, v as WebExtensionTarget, w as WebPluginRoute, x as WebSsrContractVersion, y as WebSurface, z as adminExtensionSchema, B as adminTourPlacementSchema, C as adminTourSchema, D as adminTourStepSchema, F as autoCrudActionSchema, G as autoCrudActionZoneSchema, H as autoCrudActionsSchema, I as autoCrudDataSourceSchema, J as autoCrudFieldConfigSchema, K as autoCrudFieldOptionSchema, L as dashboardTargetSchema, M as entityExtensionCrudConfigSchema, N as entityExtensionFieldSchema, O as entityExtensionSchema, Q as entityExtensionSlotSchema, R as entityExtensionUseSchema, S as navGroupTargetSchema, T as navTargetSchema, U as pluginI18nSchema, V as pluginManifestSchema, X as pluginUsesSchema, Y as routeTargetSchema, Z as settingsTargetSchema, _ as targetSchema, $ as webDesignActionSchema, a0 as webDesignBlockSchema, a1 as webDesignDataSourceSchema, a2 as webDesignSlotSchema, a3 as webDesignSurfaceSchema, a4 as webDesignTemplateSchema, a5 as webExtensionQuerySchema, a6 as webExtensionSchema, a7 as webExtensionTargetSchema, a8 as webPluginRouteSchema, a9 as webSsrContractVersionSchema, aa as webSurfaceSchema } from './manifest-CTFX-h0w.js';
+export { c as PLUGIN_ARCHIVE_MEDIA_TYPE, d as PLUGIN_RELEASE_SCHEMA_VERSION, e as PluginRegistryCatalog, f as PluginRegistryRelease, P as PluginRelease, g as PluginReleaseFile, h as PluginSignature, i as REGISTRY_CATALOG_SIGNATURE_DOMAIN, b as RegistryCatalogPageEnvelope, R as RegistryReleaseEnvelope, a as RegistrySignature, j as canonicalRegistryCatalogPageEnvelope, k as canonicalRegistryReleaseEnvelope, p as pluginArchivePathSchema, l as pluginRegistryCatalogSchema, m as pluginRegistryReleaseSchema, n as pluginReleaseFileSchema, o as pluginReleaseSchema, q as pluginSignatureSchema, r as registryCatalogPageEnvelopeSchema, s as registryCatalogPageSignaturePayload, t as registryCatalogReleasesPayload, u as registryReleaseEnvelopeSchema, v as registryReleaseSignaturePayload, w as registrySignatureSchema } from './release-BDJeO54k.js';
+export { E as ENTITY_EXTENSION_VALUES_SAVE_HOOK_ID, a as EXTENSION_PROJECT_SAVE_HOOK_ID, b as EntityExtensionProjectionValue, c as EntityExtensionValueSaveHandler, d as EntityExtensionValueSavePayload, e as EntityExtensionValueSaveResult, f as entityExtensions, r as registerEntityExtensionValueSaver } from './entity-extensions-CnhKoT4k.js';
+export { D as DashboardTarget, E as ExtensionComponentMap, G as GenericTarget, N as NavGroupTarget, a as NavTarget, P as PRESENTATION_OBSERVABILITY, b as PresentationAction, c as PresentationAdapter, d as PresentationAdapterContext, e as PresentationAdapterRenderResult, f as PresentationAdapterRenderer, g as PresentationCompatibilityCheck, h as PresentationCompatibilityResult, i as PresentationDiagnostic, j as PresentationModel, k as PresentationRegion, l as PresentationSurface, m as PresentationSurfaceRenderer, R as RouteTarget, S as SettingsTarget, n as SitePresentationRenderContext, o as SlotContext, p as StorefrontApi, q as StorefrontBrowserClient, r as StorefrontOperation, s as StorefrontOperationKind, t as StorefrontRequest, u as StorefrontResponse, v as StorefrontServerBroker, T as Target, w as ThemeAsset, x as ThemeHead, y as ThemeHomeTarget, z as ThemeIntegration, A as ThemeSiteShell, B as ThemeToken, C as ThemeTokenPreset, F as ThemeTokenType, H as ToolbarHandlerMap, U as UIExtensionDef, W as WebAppEmbed, I as WebAppEmbedConsent, J as WebAppEmbedTarget, K as WebDesignBinding, L as WebDesignMigration, M as WebDesignNodeDefinition, O as WebDesignNodeKind, Q as WebDesignRegion, V as WebPresentation, X as dashboardExtension, Y as defineAppEmbed, Z as defineExtension, _ as definePresentationAdapter, $ as definePresentationSurface, a0 as defineStorefrontApi, a1 as defineThemeHomeTarget, a2 as defineWebDesignNode, a3 as defineWebPresentation, a4 as evaluatePresentationCompatibility, a5 as multiSlotExtension, a6 as navExtension, a7 as parsePresentationModel, a8 as presentationActionSchema, a9 as presentationAdapterSchema, aa as presentationCompatibilityResultSchema, ab as presentationCompatibilityStatusSchema, ac as presentationContractRangeSchema, ad as presentationContractVersionSchema, ae as presentationDiagnosticSchema, af as presentationDiagnosticSeveritySchema, ag as presentationIdSchema, ah as presentationModelSchema, ai as presentationPluginIdSchema, aj as presentationRegionSchema, ak as presentationRenderModeSchema, al as presentationSchemaRefSchema, am as presentationSurfaceSchema, an as routeExtension, ao as satisfiesPresentationRange, ap as settingsExtension, aq as storefrontApiSchema, ar as storefrontOperationKindSchema, as as storefrontOperationSchema, at as themeAssetPathSchema, au as themeAssetSchema, av as themeHeadSchema, aw as themeHomeTargetSchema, ax as themeIntegrationSchema, ay as themeSiteShellSchema, az as themeTokenPresetSchema, aA as themeTokenSchema, aB as themeTokenTypeSchema, aC as webAppEmbedConsentSchema, aD as webAppEmbedSchema, aE as webAppEmbedTargetSchema, aF as webDesignBindingSchema, aG as webDesignMigrationSchema, aH as webDesignNodeDefinitionSchema, aI as webDesignNodeKindSchema, aJ as webDesignRegionSchema, aK as webPresentationSchema } from './client-poND5ovI.js';
+export { PluginDevRuntimeConfig, PluginPublicWebSharedName, PluginReactOptions, PluginReactSharedOptions, getPluginDevPort, getPluginDevRemoteEntry, getPluginDevRuntimeConfig, getPluginMfName, isPluginDevRemoteSelected, parsePluginList, pluginPublicWebShared, pluginReactOptions, pluginReactShared } from './dev-utils.js';
+import 'decimal.js';
+
+declare const MARKETPLACE_PUBLISH_SOURCES: readonly ["web", "cli", "github-actions"];
+declare const marketplacePublishSourceSchema: z.ZodEnum<{
+    web: "web";
+    cli: "cli";
+    "github-actions": "github-actions";
+}>;
+type MarketplacePublishSource = z.infer<typeof marketplacePublishSourceSchema>;
+declare const MARKETPLACE_PLUGIN_ICON_MEDIA_TYPES: readonly ["image/png", "image/jpeg", "image/webp", "image/gif"];
+declare const MARKETPLACE_PLUGIN_ICON_MAX_BYTES: number;
+type MarketplacePluginIconMediaType = (typeof MARKETPLACE_PLUGIN_ICON_MEDIA_TYPES)[number];
+declare const MARKETPLACE_SUBMISSION_STATUSES: readonly ["uploaded", "scanning", "review_pending", "scan_failed", "approved", "rejected"];
+declare const marketplaceSubmissionStatusSchema: z.ZodEnum<{
+    uploaded: "uploaded";
+    scanning: "scanning";
+    review_pending: "review_pending";
+    scan_failed: "scan_failed";
+    approved: "approved";
+    rejected: "rejected";
+}>;
+type MarketplaceSubmissionStatus = z.infer<typeof marketplaceSubmissionStatusSchema>;
+declare const marketplacePublisherProfileInputSchema: z.ZodObject<{
+    name: z.ZodString;
+}, z.core.$strip>;
+type MarketplacePublisherProfileInput = z.infer<typeof marketplacePublisherProfileInputSchema>;
+declare const marketplacePublisherProfileSchema: z.ZodObject<{
+    id: z.ZodString;
+    organizationId: z.ZodString;
+    name: z.ZodString;
+    trust: z.ZodEnum<{
+        first_party: "first_party";
+        third_party: "third_party";
+    }>;
+    status: z.ZodEnum<{
+        suspended: "suspended";
+        active: "active";
+    }>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+type MarketplacePublisherProfile = z.infer<typeof marketplacePublisherProfileSchema>;
+declare const marketplacePublisherProfileResponseSchema: z.ZodObject<{
+    profile: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        organizationId: z.ZodString;
+        name: z.ZodString;
+        trust: z.ZodEnum<{
+            first_party: "first_party";
+            third_party: "third_party";
+        }>;
+        status: z.ZodEnum<{
+            suspended: "suspended";
+            active: "active";
+        }>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type MarketplacePublisherProfileResponse = z.infer<typeof marketplacePublisherProfileResponseSchema>;
+declare const marketplacePublisherCapabilitiesSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    ownedPluginMetadata: z.ZodBoolean;
+    pluginIconUpload: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type MarketplacePublisherCapabilities = z.infer<typeof marketplacePublisherCapabilitiesSchema>;
+declare const marketplacePublisherCapabilitiesResponseSchema: z.ZodObject<{
+    capabilities: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        ownedPluginMetadata: z.ZodBoolean;
+        pluginIconUpload: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type MarketplacePublisherCapabilitiesResponse = z.infer<typeof marketplacePublisherCapabilitiesResponseSchema>;
+declare const marketplaceOwnedPluginInputSchema: z.ZodObject<{
+    pluginId: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    iconUrl: z.ZodOptional<z.ZodNullable<z.ZodURL>>;
+}, z.core.$strict>;
+type MarketplaceOwnedPluginInput = z.infer<typeof marketplaceOwnedPluginInputSchema>;
+declare const marketplaceOwnedPluginUpdateSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    iconUrl: z.ZodOptional<z.ZodNullable<z.ZodURL>>;
+}, z.core.$strict>;
+type MarketplaceOwnedPluginUpdate = z.infer<typeof marketplaceOwnedPluginUpdateSchema>;
+declare const marketplaceOwnedPluginSchema: z.ZodObject<{
+    pluginId: z.ZodString;
+    publisherId: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    iconUrl: z.ZodOptional<z.ZodNullable<z.ZodURL>>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+type MarketplaceOwnedPlugin = z.infer<typeof marketplaceOwnedPluginSchema>;
+declare const marketplaceOwnedPluginsResponseSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        pluginId: z.ZodString;
+        publisherId: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        iconUrl: z.ZodOptional<z.ZodNullable<z.ZodURL>>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type MarketplaceOwnedPluginsResponse = z.infer<typeof marketplaceOwnedPluginsResponseSchema>;
+declare const marketplaceOwnedPluginResponseSchema: z.ZodObject<{
+    plugin: z.ZodObject<{
+        pluginId: z.ZodString;
+        publisherId: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        iconUrl: z.ZodOptional<z.ZodNullable<z.ZodURL>>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type MarketplaceOwnedPluginResponse = z.infer<typeof marketplaceOwnedPluginResponseSchema>;
+declare const marketplaceSubmissionSchema: z.ZodObject<{
+    id: z.ZodString;
+    publisherId: z.ZodString;
+    organizationId: z.ZodString;
+    pluginId: z.ZodString;
+    version: z.ZodString;
+    status: z.ZodEnum<{
+        uploaded: "uploaded";
+        scanning: "scanning";
+        review_pending: "review_pending";
+        scan_failed: "scan_failed";
+        approved: "approved";
+        rejected: "rejected";
+    }>;
+    uploadSource: z.ZodEnum<{
+        web: "web";
+        cli: "cli";
+        "github-actions": "github-actions";
+    }>;
+    uploadActorId: z.ZodNullable<z.ZodString>;
+    uploadAuthMethod: z.ZodNullable<z.ZodEnum<{
+        "portal-session": "portal-session";
+        "scoped-api-key": "scoped-api-key";
+    }>>;
+    uploadCredentialId: z.ZodNullable<z.ZodString>;
+    uploadAuthenticatedAt: z.ZodNullable<z.ZodISODateTime>;
+    reviewReason: z.ZodNullable<z.ZodString>;
+    reviewedAt: z.ZodNullable<z.ZodISODateTime>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+type MarketplaceSubmission = z.infer<typeof marketplaceSubmissionSchema>;
+declare const marketplaceSubmissionCursorSchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+    pluginId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type MarketplaceSubmissionCursor = z.infer<typeof marketplaceSubmissionCursorSchema>;
+declare const marketplaceSubmissionsResponseSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        publisherId: z.ZodString;
+        organizationId: z.ZodString;
+        pluginId: z.ZodString;
+        version: z.ZodString;
+        status: z.ZodEnum<{
+            uploaded: "uploaded";
+            scanning: "scanning";
+            review_pending: "review_pending";
+            scan_failed: "scan_failed";
+            approved: "approved";
+            rejected: "rejected";
+        }>;
+        uploadSource: z.ZodEnum<{
+            web: "web";
+            cli: "cli";
+            "github-actions": "github-actions";
+        }>;
+        uploadActorId: z.ZodNullable<z.ZodString>;
+        uploadAuthMethod: z.ZodNullable<z.ZodEnum<{
+            "portal-session": "portal-session";
+            "scoped-api-key": "scoped-api-key";
+        }>>;
+        uploadCredentialId: z.ZodNullable<z.ZodString>;
+        uploadAuthenticatedAt: z.ZodNullable<z.ZodISODateTime>;
+        reviewReason: z.ZodNullable<z.ZodString>;
+        reviewedAt: z.ZodNullable<z.ZodISODateTime>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+type MarketplaceSubmissionsResponse = z.infer<typeof marketplaceSubmissionsResponseSchema>;
+declare const marketplaceReleaseAcceptedResponseSchema: z.ZodObject<{
+    submission: z.ZodObject<{
+        id: z.ZodString;
+        publisherId: z.ZodString;
+        organizationId: z.ZodString;
+        pluginId: z.ZodString;
+        version: z.ZodString;
+        status: z.ZodEnum<{
+            uploaded: "uploaded";
+            scanning: "scanning";
+            review_pending: "review_pending";
+            scan_failed: "scan_failed";
+            approved: "approved";
+            rejected: "rejected";
+        }>;
+        uploadSource: z.ZodEnum<{
+            web: "web";
+            cli: "cli";
+            "github-actions": "github-actions";
+        }>;
+        uploadActorId: z.ZodNullable<z.ZodString>;
+        uploadAuthMethod: z.ZodNullable<z.ZodEnum<{
+            "portal-session": "portal-session";
+            "scoped-api-key": "scoped-api-key";
+        }>>;
+        uploadCredentialId: z.ZodNullable<z.ZodString>;
+        uploadAuthenticatedAt: z.ZodNullable<z.ZodISODateTime>;
+        reviewReason: z.ZodNullable<z.ZodString>;
+        reviewedAt: z.ZodNullable<z.ZodISODateTime>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type MarketplaceReleaseAcceptedResponse = z.infer<typeof marketplaceReleaseAcceptedResponseSchema>;
+declare const marketplacePublisherErrorSchema: z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>;
+type MarketplacePublisherError = z.infer<typeof marketplacePublisherErrorSchema>;
+
+/**
+ * Plugin Definition - Type-safe plugin configuration
+ */
+interface PluginDefinition {
+    /** Plugin manifest (required fields only) */
+    manifest: Pick<PluginManifest, 'pluginId' | 'version' | 'name' | 'vendor' | 'engines'> & Partial<PluginManifest>;
+    /** Server-side exports */
+    server?: {
+        /** tRPC router (optional) */
+        router?: unknown;
+        /** Lifecycle hooks */
+        onInstall?: (ctx: PluginContext) => Promise<void>;
+        onEnable?: (ctx: PluginContext) => Promise<void>;
+        onDisable?: (ctx: PluginContext) => Promise<void>;
+        onUninstall?: (ctx: PluginContext) => Promise<void>;
+    };
+}
+/**
+ * Define a plugin with type safety
+ *
+ * @example
+ * ```ts
+ * import { definePlugin } from '@wordrhyme/plugin';
+ *
+ * export default definePlugin({
+ *   manifest: {
+ *     pluginId: 'com.example.hello',
+ *     version: '1.0.0',
+ *     name: 'Hello World',
+ *     vendor: 'Example Inc',
+ *     engines: { wordrhyme: '^0.1.0' },
+ *   },
+ *   server: {
+ *     router: myRouter,
+ *     onEnable: async (ctx) => {
+ *       ctx.logger.info('Plugin enabled!');
+ *     },
+ *   },
+ * });
+ * ```
+ */
+declare function definePlugin(definition: PluginDefinition): PluginDefinition;
+
+/**
+ * Plugin Runtime Helpers (Client-Side)
+ *
+ * Utilities for plugins to use logger and permission capabilities.
+ * These are convenience wrappers that work within plugin context.
+ */
+
+/**
+ * Create a scoped logger for a plugin
+ *
+ * @example
+ * ```ts
+ * import { createLogger } from '@wordrhyme/plugin';
+ *
+ * const logger = createLogger('com.vendor.my-plugin');
+ * logger.info('Plugin started');
+ * ```
+ */
+declare function createLogger(pluginId: string): PluginLogger;
+/**
+ * Check if a permission is granted in the context
+ *
+ * @example
+ * ```ts
+ * import { checkPermission } from '@wordrhyme/plugin';
+ *
+ * async function myHandler(ctx: PluginContext) {
+ *   if (await checkPermission(ctx, 'content:read:*')) {
+ *     // User has permission
+ *   }
+ * }
+ * ```
+ */
+declare function checkPermission(ctx: PluginContext, capability: string): Promise<boolean>;
+/**
+ * Require a permission - throws if denied
+ *
+ * @example
+ * ```ts
+ * import { requirePermission } from '@wordrhyme/plugin';
+ *
+ * async function protectedHandler(ctx: PluginContext) {
+ *   await requirePermission(ctx, 'admin:manage:*');
+ *   // Only executes if permission granted
+ * }
+ * ```
+ */
+declare function requirePermission(ctx: PluginContext, capability: string): Promise<void>;
+/**
+ * Check if plugin declared a capability in its manifest
+ *
+ * @example
+ * ```ts
+ * import { hasCapability } from '@wordrhyme/plugin';
+ *
+ * function checkDeclared(ctx: PluginContext) {
+ *   if (hasCapability(ctx, 'content:write:*')) {
+ *     // Plugin declared this capability
+ *   }
+ * }
+ * ```
+ */
+declare function hasCapability(ctx: PluginContext, capability: string): boolean;
+
+type WebUrlSearchValue = boolean | number | string | null | undefined;
+type WebUrlSearchParams = URLSearchParams | Record<string, WebUrlSearchValue>;
+/**
+ * Builds an absolute URL for a public Web route without assuming how the site
+ * is hosted. Custom domains and platform subdomains use an empty basePath;
+ * platform-path sites provide a basePath such as `/s/acme`.
+ */
+declare function buildWebUrl(site: Pick<WebPluginSiteInfo, 'basePath' | 'publicOrigin'> | null | undefined, href: string, searchParams?: WebUrlSearchParams): string | null;
+
+declare const AI_ERROR_I18N_KEYS: {
+    readonly AI_ALIAS_NOT_DECLARED: "errors.ai.aliasNotDeclared";
+    readonly AI_BALANCE_INSUFFICIENT: "errors.ai.balanceInsufficient";
+    readonly AI_BUDGET_EXCEEDED: "errors.ai.budgetExceeded";
+    readonly AI_CONFIG_INVALID: "errors.ai.configInvalid";
+    readonly AI_CONFIG_REQUIRED: "errors.ai.configRequired";
+    readonly AI_CONFIG_REVISION_STALE: "errors.ai.configRevisionStale";
+    readonly AI_CONNECTION_FAILED: "errors.ai.connectionFailed";
+    readonly AI_CONNECTION_NOT_FOUND: "errors.ai.connectionNotFound";
+    readonly AI_CONTEXT_REQUIRED: "errors.ai.contextRequired";
+    readonly AI_CREDENTIAL_INVALID: "errors.ai.credentialInvalid";
+    readonly AI_CREDENTIAL_REQUIRED: "errors.ai.credentialRequired";
+    readonly AI_DEFAULT_MODEL_NOT_FOUND: "errors.ai.defaultModelNotFound";
+    readonly AI_MODEL_NOT_FOUND: "errors.ai.modelNotFound";
+    readonly AI_MODEL_SELECTION_INVALID: "errors.ai.modelSelectionInvalid";
+    readonly AI_PROVIDER_ABORTED: "errors.ai.providerAborted";
+    readonly AI_PROVIDER_FAILED: "errors.ai.providerFailed";
+    readonly AI_QUOTA_EXCEEDED: "errors.ai.quotaExceeded";
+    readonly AI_RUNTIME_FAILED: "errors.ai.runtimeFailed";
+    readonly AI_RUNTIME_HOST_SERVICES_UNAVAILABLE: "errors.ai.runtimeHostServicesUnavailable";
+    readonly AI_RUNTIME_READINESS_UNAVAILABLE: "errors.ai.runtimeReadinessUnavailable";
+    readonly AI_RUNTIME_UNAVAILABLE: "errors.ai.runtimeUnavailable";
+};
+type AiErrorCode = keyof typeof AI_ERROR_I18N_KEYS;
+type AiErrorI18nKey = (typeof AI_ERROR_I18N_KEYS)[AiErrorCode];
+interface AiErrorDescriptor {
+    code: AiErrorCode;
+    i18nKey: AiErrorI18nKey;
+}
+declare function aiErrorDescriptor(error: unknown): AiErrorDescriptor | undefined;
+declare function formatAiError(error: unknown, translateCommon: Translator, fallback: string): string;
+
+/**
+ * Agent tool assembly + pre-call governance (AI Action Gateway, Phase 1).
+ *
+ * Translates the governed Action Catalog into the tool shape an LLM runtime
+ * consumes, and enforces the rules that must hold BEFORE a model-proposed call
+ * reaches the invoker. Kept in the SDK so any agent-host plugin gets identical
+ * semantics rather than re-deriving them.
+ *
+ * Two rules carry most of the weight (plan §9):
+ *
+ *   - **The model never picks a procedure path.** Tools are named after stable
+ *     `actionId`s; the Host resolves the binding. A hallucinated tool name is a
+ *     miss, not an arbitrary call.
+ *   - **The model cannot talk its way past a confirmation.** Risk comes from the
+ *     curated contract, never from tool output or model reasoning, and high-risk
+ *     calls are refused here unless an approval token is already present.
+ *
+ * Both rules assume the tool name arrived as protocol data. `ToolChannel` is
+ * where that assumption is made explicit and enforced.
+ */
+/**
+ * How a tool call reached us.
+ *
+ * `native` — the provider returned a structured tool call over its own protocol,
+ * so the tool name is a protocol fact and maps to a curated `actionId`.
+ *
+ * `text-recovered` — the call was parsed out of the model's prose, the way
+ * text-mode runtimes recover DeepSeek DSML markup and similar. There the tool
+ * name *is* model-authored free text, which collapses the boundary the two rules
+ * above rest on: prose becomes the source of the action to run. Such a channel
+ * therefore carries `query` actions only — a channel that cannot be trusted to
+ * name an action cannot be trusted to change data.
+ */
+type ToolChannel = "native" | "text-recovered";
+/** Minimal shape of a catalog entry; mirrors ActionDescriptor without importing it. */
+interface AgentToolSource {
+    actionId: string;
+    revision: number;
+    kind: "query" | "command";
+    risk: "low" | "medium" | "high";
+    summary?: string | undefined;
+}
+/** JSON-Schema-shaped tool definition, the lingua franca of tool-calling APIs. */
+interface AgentToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: Record<string, unknown>;
+        required?: string[];
+        additionalProperties: boolean;
+    };
+    /** Curated metadata; NOT model-supplied and NOT to be trusted from tool output. */
+    metadata: {
+        actionId: string;
+        revision: number;
+        kind: "query" | "command";
+        risk: "low" | "medium" | "high";
+        requiresApproval: boolean;
+    };
+}
+interface AssembleOptions {
+    /** Argument schemas by actionId, when the host can supply them. */
+    argumentSchemas?: Record<string, {
+        properties: Record<string, unknown>;
+        required?: string[];
+    }>;
+    /** Drop actions above this risk level from what the model can even see. */
+    maxRisk?: "low" | "medium" | "high";
+    /**
+     * The channel these tools will be offered on. A `text-recovered` channel is
+     * assembled without commands, so the model is never shown a write the gate
+     * would refuse anyway. Defaults to `native`: this is a pure helper, and the
+     * callers that hold a real channel (`runAgent`, the host endpoints) are the
+     * ones that treat an undeclared channel as untrusted.
+     */
+    channel?: ToolChannel;
+}
+/** Tool names must survive provider naming rules (letters, digits, _, -). */
+declare function toolNameFor(actionId: string): string;
+declare function requiresApprovalFor(risk: AgentToolSource["risk"]): boolean;
+/**
+ * Build the tool list exposed to a model.
+ *
+ * Descriptions state the governance consequence explicitly: models behave better
+ * when told a call will pause for a human than when silently refused later.
+ */
+declare function assembleTools(sources: readonly AgentToolSource[], options?: AssembleOptions): AgentToolDefinition[];
+type ToolCallDecision = {
+    allow: true;
+    actionId: string;
+    revision: number;
+} | {
+    allow: false;
+    reason: ToolCallRefusal;
+    message: string;
+};
+type ToolCallRefusal = "UNKNOWN_TOOL" | "APPROVAL_REQUIRED" | "BUDGET_EXHAUSTED" | "TENANT_PAUSED" | "CHANNEL_READ_ONLY";
+interface ToolCallGateInput {
+    toolName: string;
+    tools: readonly AgentToolDefinition[];
+    /** Present when the caller already holds a human approval for this call. */
+    approvalToken?: string | undefined;
+    /** Remaining tool calls in this run; `undefined` means unbounded. */
+    remainingCalls?: number | undefined;
+    /** Tenant-level kill switch for AI writes (plan §9 resource exhaustion). */
+    writesPaused?: boolean;
+    /** How this call reached us; a `text-recovered` channel carries reads only. */
+    channel?: ToolChannel;
+}
+/**
+ * Decide whether a model-proposed tool call may proceed.
+ *
+ * Runs before the invoker so refusals cost nothing and can be fed back to the
+ * model as a normal tool result — a refused call should steer the model, not
+ * crash the run.
+ */
+declare function gateToolCall(input: ToolCallGateInput): ToolCallDecision;
+/**
+ * Wrap a tool result before it re-enters the model context.
+ *
+ * Tool output is untrusted input (plan §9 malicious tool output): it is fenced
+ * and labelled so the model cannot pass it off as an instruction, and it can
+ * never carry governance metadata of its own.
+ */
+declare function encodeToolResult(actionId: string, result: unknown): string;
+
+/**
+ * Governed agent run loop (AI Action Gateway, Phase 1).
+ *
+ * The multi-turn loop that sits between a model and the governed action
+ * surface. It is deliberately **model-agnostic**: the LLM is reached through a
+ * narrow `ModelClient` seam, so the chosen runtime (Pi — see
+ * `docs/architecture/adr/2026-07-27-agent-runtime-pi.md`) is one implementation
+ * rather than a structural dependency, and the whole governance path is
+ * testable without a network or API key.
+ *
+ * What the loop guarantees, regardless of what the model does:
+ *
+ *   - **Budgets are hard.** Turn and tool-call ceilings are enforced by the loop,
+ *     not requested of the model. A runaway loop stops.
+ *   - **Refusals steer, they don't crash.** A gated call returns a tool result
+ *     explaining why, so the model can adapt; only infrastructure faults throw.
+ *   - **Tool output is data.** Results are fenced and labelled before re-entering
+ *     the context, and can never redirect which action runs next — the actionId
+ *     always comes from the curated catalog via the tool name.
+ *   - **Prose cannot become a command.** That last guarantee holds only while the
+ *     tool name is protocol data, so a client that recovers calls from model text
+ *     (`channel: 'text-recovered'`) is confined to read-only actions.
+ *   - **High-risk work pauses.** A call needing approval suspends the run with
+ *     everything the caller needs to raise a confirmation, instead of guessing.
+ */
+
+interface ModelToolCall {
+    id: string;
+    /** Tool name as emitted by the model; resolved against the catalog, never trusted as a path. */
+    name: string;
+    arguments?: unknown;
+}
+interface ModelMessage {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string;
+    toolCalls?: ModelToolCall[];
+    toolCallId?: string;
+}
+interface ModelResponse {
+    text?: string;
+    toolCalls?: ModelToolCall[];
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        costUsd?: number;
+    };
+}
+interface ModelClient {
+    /**
+     * How this client surfaces tool calls. An adapter that parses them out of the
+     * model's prose rather than reading them off the wire MUST declare
+     * `text-recovered`; the loop then withholds every command action.
+     *
+     * Required so the choice is made by whoever writes the adapter, who is the
+     * only one who knows. An absent value is treated as `text-recovered` — the
+     * restrictive reading — because reaching that line means the declaration was
+     * bypassed rather than considered.
+     */
+    readonly channel: ToolChannel;
+    complete(input: {
+        messages: ModelMessage[];
+        tools: AgentToolDefinition[];
+        signal?: AbortSignal;
+    }): Promise<ModelResponse>;
+}
+/** Executes an accepted call. Implemented by the host over `ctx.actions.invoke`. */
+type ActionExecutor = (call: {
+    actionId: string;
+    revision: number;
+    args: unknown;
+}) => Promise<unknown>;
+type AgentRunEvent = {
+    type: "turn.started";
+    turn: number;
+} | {
+    type: "message.completed";
+    text: string;
+} | {
+    type: "tool.started";
+    toolName: string;
+    actionId: string;
+} | {
+    type: "tool.completed";
+    actionId: string;
+} | {
+    type: "tool.refused";
+    toolName: string;
+    reason: ToolCallRefusal;
+} | {
+    type: "tool.approval_required";
+    toolName: string;
+    actionId: string;
+    args: unknown;
+} | {
+    type: "run.completed";
+    reason: RunStopReason;
+} | {
+    type: "run.failed";
+    error: string;
+};
+type RunStopReason = "completed" | "turn_budget" | "tool_budget" | "approval_required" | "aborted";
+interface AgentRunOptions {
+    model: ModelClient;
+    tools: AgentToolDefinition[];
+    execute: ActionExecutor;
+    messages: ModelMessage[];
+    maxTurns?: number;
+    maxToolCalls?: number;
+    /** Tenant kill switch for AI writes; reads continue. */
+    writesPaused?: boolean;
+    /** Approval tokens already held, keyed by actionId. */
+    approvals?: Record<string, string>;
+    onEvent?: (event: AgentRunEvent) => void;
+    signal?: AbortSignal;
+}
+interface AgentRunResult {
+    stopReason: RunStopReason;
+    messages: ModelMessage[];
+    text: string;
+    toolCallsUsed: number;
+    turnsUsed: number;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+        costUsd: number;
+    };
+    /** Set when `stopReason === 'approval_required'`. */
+    pendingApproval?: {
+        toolName: string;
+        actionId: string;
+        revision: number;
+        args: unknown;
+    };
+}
+declare function runAgent(options: AgentRunOptions): Promise<AgentRunResult>;
+
+/**
+ * WordRhyme Connector — one codebase, two transports (AI Action Gateway, Phase 0 segment 3).
+ *
+ * `local`  — invokes governed actions in-process through `ctx.actions`
+ *            (ActionInvokerCapability); identity comes from the live request.
+ * `remote` — invokes the SAME action surface on ANOTHER WordRhyme instance over
+ *            HTTP `POST {baseUrl}/trpc/<path>` with `x-api-key`.
+ *
+ * Both transports share the `invoke(actionId, revision, args)` shape, so callers
+ * cannot tell them apart — that is the point of the segment-3 spike.
+ *
+ * Security posture (all fail closed):
+ *   - remote base URLs must be explicitly allowlisted; private/loopback hosts are
+ *     rejected unless the allowlist entry itself is loopback (dev/tests)
+ *   - redirects are never followed (`redirect: 'error'`) — no redirect-to-private-net
+ *   - the remote instance pins the organization to its API token; this client
+ *     therefore never sends an organizationId, and refuses to accept one
+ *   - `onBehalfOf` is delegation CONTEXT FOR AUDIT ONLY, never a permission source;
+ *     the remote side authorizes as the token's own principal
+ */
+/** Actions surface the local transport delegates to (subset of PluginActionInvokerCapability). */
+interface ConnectorLocalActions {
+    invoke(request: {
+        actionId: string;
+        revision: number;
+        args?: unknown;
+    }): Promise<unknown>;
+}
+interface ConnectorInvokeRequest {
+    actionId: string;
+    revision: number;
+    args?: unknown;
+    /** Audit-only delegation context. Never widens permissions on either side. */
+    onBehalfOf?: string;
+}
+interface WordRhymeConnector {
+    readonly transport: "local" | "remote";
+    invoke(request: ConnectorInvokeRequest): Promise<unknown>;
+}
+interface LocalConnectorOptions {
+    transport: "local";
+    actions: ConnectorLocalActions;
+}
+interface RemoteConnectorOptions {
+    transport: "remote";
+    baseUrl: string;
+    apiKey: string;
+    /** Exact origins this connector may call. Empty ⇒ nothing is allowed. */
+    allowedOrigins: string[];
+    /** Action ids this connector may invoke remotely. Empty ⇒ nothing is allowed. */
+    allowedActions: string[];
+    /** Injected for tests; defaults to global fetch. */
+    fetchImpl?: typeof fetch;
+}
+type ConnectorOptions = LocalConnectorOptions | RemoteConnectorOptions;
+declare class ConnectorError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+/**
+ * Resolve a remote base URL against the allowlist.
+ * Private/loopback targets are only permitted when explicitly allowlisted,
+ * which keeps dev and tests usable without opening SSRF in production configs.
+ */
+declare function resolveRemoteOrigin(baseUrl: string, allowedOrigins: string[]): string;
+declare function createWordRhymeConnector(options: ConnectorOptions): WordRhymeConnector;
+
+export { AI_ERROR_I18N_KEYS, type ActionExecutor, type AgentRunEvent, type AgentRunOptions, type AgentRunResult, type AgentToolDefinition, type AgentToolSource, type AiErrorCode, type AiErrorDescriptor, type AiErrorI18nKey, type AssembleOptions, ConnectorError, type ConnectorInvokeRequest, type ConnectorLocalActions, type ConnectorOptions, type LocalConnectorOptions, MARKETPLACE_PLUGIN_ICON_MAX_BYTES, MARKETPLACE_PLUGIN_ICON_MEDIA_TYPES, MARKETPLACE_PUBLISH_SOURCES, MARKETPLACE_SUBMISSION_STATUSES, type MarketplaceOwnedPlugin, type MarketplaceOwnedPluginInput, type MarketplaceOwnedPluginResponse, type MarketplaceOwnedPluginUpdate, type MarketplaceOwnedPluginsResponse, type MarketplacePluginIconMediaType, type MarketplacePublishSource, type MarketplacePublisherCapabilities, type MarketplacePublisherCapabilitiesResponse, type MarketplacePublisherError, type MarketplacePublisherProfile, type MarketplacePublisherProfileInput, type MarketplacePublisherProfileResponse, type MarketplaceReleaseAcceptedResponse, type MarketplaceSubmission, type MarketplaceSubmissionCursor, type MarketplaceSubmissionStatus, type MarketplaceSubmissionsResponse, type ModelClient, type ModelMessage, type ModelResponse, type ModelToolCall, PluginContext, PluginLogger, PluginManifest, type RemoteConnectorOptions, type RunStopReason, type ToolCallDecision, type ToolCallGateInput, type ToolCallRefusal, type ToolChannel, Translator, WebPluginSiteInfo, type WebUrlSearchParams, type WebUrlSearchValue, type WordRhymeConnector, aiErrorDescriptor, assembleTools, buildWebUrl, checkPermission, createLogger, createWordRhymeConnector, definePlugin, encodeToolResult, formatAiError, gateToolCall, hasCapability, marketplaceOwnedPluginInputSchema, marketplaceOwnedPluginResponseSchema, marketplaceOwnedPluginSchema, marketplaceOwnedPluginUpdateSchema, marketplaceOwnedPluginsResponseSchema, marketplacePublishSourceSchema, marketplacePublisherCapabilitiesResponseSchema, marketplacePublisherCapabilitiesSchema, marketplacePublisherErrorSchema, marketplacePublisherProfileInputSchema, marketplacePublisherProfileResponseSchema, marketplacePublisherProfileSchema, marketplaceReleaseAcceptedResponseSchema, marketplaceSubmissionCursorSchema, marketplaceSubmissionSchema, marketplaceSubmissionStatusSchema, marketplaceSubmissionsResponseSchema, requirePermission, requiresApprovalFor, resolveRemoteOrigin, runAgent, toolNameFor };