@23blocks/angular 6.5.15 → 6.5.16

package/dist/index.d.ts

@@ -1 +1,3874 @@
-export * from "./src/index";
+import * as i0 from '@angular/core';
+import { EnvironmentProviders, Provider, InjectionToken } from '@angular/core';
+import { Transport, ListParams, PageResult } from '@23blocks/contracts';
+import { AuthenticationBlockConfig, SignInRequest, SignInResponse, SignUpRequest, SignUpResponse, PasswordResetRequest, PasswordUpdateRequest, TokenValidationResponse, User, RefreshTokenRequest, RefreshTokenResponse, MagicLinkRequest, MagicLinkVerifyRequest, InvitationRequest, AcceptInvitationRequest, ResendConfirmationRequest, ValidateEmailRequest, ValidateEmailResponse, ValidateDocumentRequest, ValidateDocumentResponse, ResendInvitationRequest, AccountRecoveryRequest, AccountRecoveryResponse, CompleteRecoveryRequest, UpdateUserRequest, UpdateProfileRequest, UserSearchRequest, UserProfileFull, ProfileRequest, UpdateEmailRequest, UserDeviceFull, AddDeviceRequest, Company, AddUserSubscriptionRequest, UserSubscription, Role, CreateRoleRequest, UpdateRoleRequest, Permission, CreatePermissionRequest, UpdatePermissionRequest, ApiKey, CreateApiKeyRequest, ApiKeyWithSecret, UpdateApiKeyRequest, MfaSetupResponseFull, MfaEnableRequest, MfaOperationResponse, MfaDisableRequest, MfaVerifyRequestFull, MfaVerificationResponse, MfaStatusResponse, OAuthSocialLoginRequest, TenantLoginRequest, TokenIntrospectionResponse, TokenRevokeRequest, TokenRevokeResponse, TokenRevokeAllRequest, TenantContextCreateRequest, TenantContextResponse, TenantContextAuditEntry, UserAvatarFull, CreateAvatarRequest, AvatarPresignResponse, MultipartPresignRequest, MultipartPresignResponse, MultipartCompleteRequest, MultipartCompleteResponse, ValidateTenantCodeRequest, ValidateTenantCodeResponse, SearchTenantRequest, CreateTenantUserRequest, TenantUserFull, UpdateTenantUserOnboardingRequest, UpdateTenantUserSalesRequest, App, CreateAppRequest, UpdateAppRequest, Block, Service, SubscriptionModel, SubscribeRequest, CompanySubscription, Country, State, County, City, Currency, Guest, MagicLink, CreateMagicLinkRequest, RefreshToken, UserDevice, RegisterDeviceRequest, TenantUser, MailTemplate, JwksResponse, RsaKey, CreateRsaKeyRequest, RotateRsaKeyRequest, OidcDiscovery, OidcAuthorizeRequest, OidcTokenRequest, OidcTokenResponse, OidcUserInfo, AuthenticationBlock } from '@23blocks/block-authentication';
+import { SearchBlockConfig, SearchRequest, SearchResponse, SearchResult, EntityType, LastQuery, SearchQuery, FavoriteEntity, AddFavoriteRequest, ListEntitiesParams, SearchEntity, RegisterEntityRequest, UpdateEntityRequest, EntityTypeSchema, CopilotSearchRequest, ListIdentitiesParams, SearchIdentity, RegisterIdentityRequest, UpdateIdentityRequest, JarvisSearchQuery, JarvisSearchResult, SearchBlock } from '@23blocks/block-search';
+import { GeolocationBlockConfig, ListLocationsParams, Location, CreateLocationRequest, UpdateLocationRequest, ListAddressesParams, Address, CreateAddressRequest, UpdateAddressRequest, ListAreasParams, Area, CreateAreaRequest, UpdateAreaRequest, ListRegionsParams, Region, CreateRegionRequest, UpdateRegionRequest, ListTravelRoutesParams, TravelRoute, CreateTravelRouteRequest, UpdateTravelRouteRequest, ListPremiseBookingsParams, PremiseBooking, CreatePremiseBookingRequest, UpdatePremiseBookingRequest, ListPremisesParams, Premise, CreatePremiseRequest, UpdatePremiseRequest, ListPremiseEventsParams, PremiseEvent, CreatePremiseEventRequest, UpdatePremiseEventRequest, CreateRouteLocationRequest, RouteLocation, RouteTrackerStatus, ListRouteLocationsParams, LocationHour, CreateLocationHourRequest, UpdateLocationHourRequest, PresignLocationImageRequest, PresignLocationImageResponse, CreateLocationImageRequest, LocationImage, LocationSlot, CreateLocationSlotRequest, UpdateLocationSlotRequest, CreateLocationTaxRequest, LocationTax, UpdateLocationTaxRequest, ListLocationGroupsParams, LocationGroup, CreateLocationGroupRequest, ListGeoIdentitiesParams, GeoIdentity, RegisterGeoIdentityRequest, UpdateGeoIdentityRequest, LocationIdentityRequest, UserLocationRequest, ListLocationIdentitiesParams, LocationIdentity, CreateLocationIdentityRequest, UpdateLocationIdentityRequest, GeoLookupParams, GeoCountry, GeoState, GeoCity, GeolocationBlock } from '@23blocks/block-geolocation';
+import { ContentBlockConfig, ListPostsParams, Post, CreatePostRequest, UpdatePostRequest, ListCommentsParams, Comment, CreateCommentRequest, UpdateCommentRequest, ListCategoriesParams as ListCategoriesParams$2, Category as Category$2, CreateCategoryRequest as CreateCategoryRequest$2, UpdateCategoryRequest as UpdateCategoryRequest$2, ListTagsParams, Tag, CreateTagRequest, UpdateTagRequest, ListContentUsersParams, ContentUser, RegisterContentUserRequest, UpdateContentUserRequest, UserActivity, ModerateContentRequest, ModerationResult, ListContentFlagsParams, ContentFlag, CreateContentFlagRequest, ListActivitiesParams, Activity, ListSeriesParams, Series, QuerySeriesParams, CreateSeriesRequest, UpdateSeriesRequest, ReorderPostsRequest, ContentBlock } from '@23blocks/block-content';
+import { CrmBlockConfig, ListAccountsParams, Account, CreateAccountRequest, UpdateAccountRequest, ListContactsParams, Contact, CreateContactRequest, UpdateContactRequest, ListContactEventsParams, ContactEvent, CreateContactEventRequest, UpdateContactEventRequest, ConfirmationRequest, CheckinRequest, CheckoutRequest as CheckoutRequest$1, EventNotesRequest, ListLeadsParams, Lead, CreateLeadRequest, UpdateLeadRequest, ListLeadFollowsParams, LeadFollow, CreateLeadFollowRequest, UpdateLeadFollowRequest, ListOpportunitiesParams, Opportunity, CreateOpportunityRequest, UpdateOpportunityRequest, ListMeetingsParams, Meeting, CreateMeetingRequest, UpdateMeetingRequest, ListMeetingParticipantsParams, MeetingParticipant, CreateMeetingParticipantRequest, ListMeetingBillingsParams, MeetingBilling, CreateMeetingBillingRequest, UpdateMeetingBillingRequest, PaymentSplit, EapSession, OutstandingByPayer, BillingRevenueReport, BillingAgingReport, BillingParticipantReport, ListQuotesParams, Quote, CreateQuoteRequest, UpdateQuoteRequest, ListSubscribersParams, Subscriber, CreateSubscriberRequest, UpdateSubscriberRequest, ListReferralsParams, Referral, CreateReferralRequest, UpdateReferralRequest, ListTouchesParams, Touch, CreateTouchRequest, UpdateTouchRequest, ListCategoriesParams as ListCategoriesParams$1, Category as Category$1, CreateCategoryRequest as CreateCategoryRequest$1, UpdateCategoryRequest as UpdateCategoryRequest$1, ListCalendarAccountsParams, CalendarAccount, CreateCalendarAccountRequest, UpdateCalendarAccountRequest, SyncCalendarRequest, SyncCalendarResponse, ListBusyBlocksParams, BusyBlock, CreateBusyBlockRequest, ListIcsTokensParams, IcsToken, CreateIcsTokenRequest, ZoomMeeting, ProvisionZoomMeetingRequest, UpdateZoomMeetingRequest, ZoomAvailability, ListZoomHostsParams, ZoomHost, CreateZoomHostRequest, UpdateZoomHostRequest, ZoomHostAvailability, ZoomHostAllocation, AvailableUser, ListCrmMailTemplatesParams, CrmMailTemplate, CreateCrmMailTemplateRequest, UpdateCrmMailTemplateRequest, MandrillTemplateStats, CreateMandrillTemplateRequest, UpdateMandrillTemplateRequest, UnsubscribeRequest, UnsubscribeResponse, ListCrmUsersParams, CrmUser, RegisterCrmUserRequest, BillingReportParams, RevenueReport, AgingReport, ParticipantBillingReport, CalendarSyncResult, CrmBlock } from '@23blocks/block-crm';
+import { ProductsBlockConfig, ListProductsParams, Product, CreateProductRequest, UpdateProductRequest, ProductVariation, CreateVariationRequest, UpdateVariationRequest, ProductImage, ProductStock, ProductReview, Cart, UpdateCartRequest, AddToCartRequest, UpdateCartItemRequest, CartDetail, CheckoutRequest, ListCategoriesParams, Category, CreateCategoryRequest, UpdateCategoryRequest, Brand, CreateBrandRequest, UpdateBrandRequest, ListVendorsParams, Vendor, CreateVendorRequest, UpdateVendorRequest, ListWarehousesParams, Warehouse, CreateWarehouseRequest, UpdateWarehouseRequest, Channel, Collection, ListProductSetsParams, ProductSet, CreateProductSetRequest, UpdateProductSetRequest, ListShoppingListsParams, ShoppingList, CreateShoppingListRequest, UpdateShoppingListRequest, ListProductPromotionsParams, ProductPromotion, CreateProductPromotionRequest, UpdateProductPromotionRequest, ListProductPricesParams, ProductPrice, CreateProductPriceRequest, UpdateProductPriceRequest, ListProductFiltersParams, ProductFilter, CreateProductFilterRequest, UpdateProductFilterRequest, UpdateMyCartRequest, AddToMyCartRequest, AbandonedCartsParams, AbandonedCart, CreateVisitorRequest, Visitor, ListProductVendorsParams, ProductVendor, ProductsBlock } from '@23blocks/block-products';
+import { ConversationsBlockConfig, ListMessagesParams, Message, CreateMessageRequest, UpdateMessageRequest, ListDraftMessagesParams, DraftMessage, CreateDraftMessageRequest, UpdateDraftMessageRequest, ListGroupsParams, Group, CreateGroupRequest, UpdateGroupRequest, ListGroupInvitesParams, GroupInvite, CreateGroupInviteRequest, QRCodeResponse, JoinGroupRequest, ListNotificationsParams, Notification, CreateNotificationRequest, UpdateNotificationRequest, GetConversationParams, Conversation, CreateWebSocketTokenRequest, CreateWebSocketTokenResponse, ListContextsParams, Context, CreateContextRequest, UpdateContextRequest, NotificationSettings, UpdateNotificationSettingsRequest, UserAvailability, SetAvailabilityRequest, MessageFile, CreateMessageFileRequest, PresignMessageFileRequest, PresignMessageFileResponse, Source, ListUsersParams, ConversationsUser, RegisterUserRequest, UpdateUserRequest as UpdateUserRequest$1, ListMeetingsParams as ListMeetingsParams$1, Meeting as Meeting$1, CreateMeetingRequest as CreateMeetingRequest$1, UpdateMeetingRequest as UpdateMeetingRequest$1, MeetingSession, ListWebNotificationsParams, WebNotification, CreateWebNotificationRequest, BulkWebNotificationRequest, ConversationsBlock } from '@23blocks/block-conversations';
+import { FilesBlockConfig, ListStorageFilesParams, StorageFile, UploadFileRequest, CreateStorageFileRequest, UpdateStorageFileRequest, ListEntityFilesParams, EntityFile, AttachFileRequest, UpdateEntityFileRequest, ReorderFilesRequest, ListFileSchemasParams, FileSchema, CreateFileSchemaRequest, UpdateFileSchemaRequest, ListUserFilesParams, UserFile, AddUserFileRequest, UpdateUserFileRequest, PresignUploadRequest, PresignUploadResponse, MultipartPresignRequest as MultipartPresignRequest$1, MultipartPresignResponse as MultipartPresignResponse$1, MultipartCompleteRequest as MultipartCompleteRequest$1, FileAccess, FileAccessRequest, FileDelegation, CreateDelegationRequest, ListFileCategoriesParams, FileCategory, CreateFileCategoryRequest, UpdateFileCategoryRequest, ListFileTagsParams, FileTag, CreateFileTagRequest, UpdateFileTagRequest, ListFileDelegationsParams, CreateFileDelegationRequest, UpdateFileDelegationRequest, ListFileAccessParams, CreateFileAccessRequest, UpdateFileAccessRequest, ListFileAccessRequestsParams, CreateFileAccessRequestInput, ReviewFileAccessRequestInput, FilesBlock } from '@23blocks/block-files';
+import { AssetsBlockConfig, ListAssetsParams, Asset, CreateAssetRequest, UpdateAssetRequest, TransferAssetRequest, AssignAssetRequest, AddToCategoryRequest, AddPartsRequest, RemovePartsRequest, UpdateMaintenanceRequest, LendAssetRequest, CreateOTPRequest, OTPResponse, ListAssetEventsParams, AssetEvent, CreateAssetEventRequest, UpdateAssetEventRequest, EventReportParams, EventReportList, EventReportSummary, EventImagePresignResponse, CreateEventImageRequest, EventImage, ListAssetAuditsParams, AssetAudit, CreateAssetAuditRequest, UpdateAssetAuditRequest, ListCategoriesParams as ListCategoriesParams$3, Category as Category$3, CreateCategoryRequest as CreateCategoryRequest$3, UpdateCategoryRequest as UpdateCategoryRequest$3, CategoryPresignResponse, CreateCategoryImageRequest, CategoryImage, ListTagsParams as ListTagsParams$1, Tag as Tag$1, CreateTagRequest as CreateTagRequest$1, UpdateTagRequest as UpdateTagRequest$1, ListVendorsParams as ListVendorsParams$1, Vendor as Vendor$1, CreateVendorRequest as CreateVendorRequest$1, UpdateVendorRequest as UpdateVendorRequest$1, ListWarehousesParams as ListWarehousesParams$1, Warehouse as Warehouse$1, CreateWarehouseRequest as CreateWarehouseRequest$1, UpdateWarehouseRequest as UpdateWarehouseRequest$1, ListAssetsEntitiesParams, AssetsEntity, CreateAssetsEntityRequest, UpdateAssetsEntityRequest, EntityAccess, CreateAccessRequestRequest, AccessRequest, ListAssetOperationsParams, AssetOperation, CreateAssetOperationRequest, OperationReportParams, OperationReportSummary, AssetAlert, CreateAssetAlertRequest, ListAssetsUsersParams, AssetsUser, RegisterAssetsUserRequest, UpdateAssetsUserRequest, UserOwnership, AssetPresignResponse, CreateAssetImageRequest, AssetImage, AssetsBlock } from '@23blocks/block-assets';
+import { FormsBlockConfig, ListFormsParams, Form, CreateFormRequest, UpdateFormRequest, ListFormSchemasParams, FormSchema, CreateFormSchemaRequest, UpdateFormSchemaRequest, ListFormSchemaVersionsParams, FormSchemaVersion, CreateFormSchemaVersionRequest, UpdateFormSchemaVersionRequest, ListFormInstancesParams, FormInstance, CreateFormInstanceRequest, UpdateFormInstanceRequest, SubmitFormInstanceRequest, ListFormSetsParams, FormSet, CreateFormSetRequest, UpdateFormSetRequest, ListLandingsParams, Landing, CreateLandingRequest, UpdateLandingRequest, ListSubscriptionsParams, Subscription, CreateSubscriptionRequest, UpdateSubscriptionRequest, ListAppointmentsParams, Appointment, CreateAppointmentRequest, UpdateAppointmentRequest, AppointmentReportRequest, AppointmentReportSummary, ListSurveysParams, Survey, SurveyStatus, CreateSurveyRequest, UpdateSurveyRequest, UpdateSurveyStatusRequest, ListReferralsParams as ListReferralsParams$1, Referral as Referral$1, CreateReferralRequest as CreateReferralRequest$1, UpdateReferralRequest as UpdateReferralRequest$1, ListMailTemplatesParams, MailTemplate as MailTemplate$1, CreateMailTemplateRequest, UpdateMailTemplateRequest, ApplicationForm, ApplicationFormSubmission, ApplicationFormResponse, ApplicationFormDraft, SendOtpResponse, VerifyOtpRequest, CrmSyncResult, CrmSyncBatchRequest, CrmSyncBatchResult, CrmConnectionStatus, CrmSyncStatus, FormsBlock } from '@23blocks/block-forms';
+import { SalesBlockConfig, ListOrdersParams, Order, CreateOrderRequest, UpdateOrderRequest, OrderDetail, UpdateOrderDetailRequest, ListPaymentsParams, Payment, CreatePaymentRequest, ListSubscriptionsParams as ListSubscriptionsParams$1, Subscription as Subscription$1, CreateSubscriptionRequest as CreateSubscriptionRequest$1, UpdateSubscriptionRequest as UpdateSubscriptionRequest$1, OrderTax, CreateOrderTaxRequest, UpdateOrderTaxRequest, ListSubscriptionModelsParams, SubscriptionModel as SubscriptionModel$1, CreateSubscriptionModelRequest, UpdateSubscriptionModelRequest, ListSalesEntitiesParams, SalesEntity, RegisterSalesEntityRequest, UpdateSalesEntityRequest, CreateEntitySubscriptionRequest, EntitySubscription, UpdateEntitySubscriptionRequest, ListSalesUsersParams, SalesUser, RegisterSalesUserRequest, UpdateSalesUserRequest, CreateUserSubscriptionRequest, UserSubscription as UserSubscription$1, UpdateUserSubscriptionRequest, ListSalesCustomersParams, SalesCustomer, CreateSalesCustomerRequest, UpdateSalesCustomerRequest, ListFlexibleOrdersParams, FlexibleOrder, CreateFlexibleOrderRequest, UpdateFlexibleOrderRequest, ListVendorPaymentsParams, VendorPayment, CreateVendorPaymentRequest, UpdateVendorPaymentRequest, CreateStripeCustomerRequest, CreateStripeCustomerResponse, CreateStripeCheckoutSessionRequest, StripeCheckoutSession, CreateStripePaymentIntentRequest, StripePaymentIntent, CreateStripeCustomerPortalRequest, StripeCustomerPortalSession, ListStripeSubscriptionsParams, StripeSubscription, CreateStripeSubscriptionRequest, UpdateStripeSubscriptionRequest, StripeWebhook, CreateStripeWebhookRequest, MercadoPagoPaymentMethod, CreateMercadoPagoPaymentRequest, MercadoPagoPaymentIntent, CreateMercadoPagoPSERequest, SalesBlock } from '@23blocks/block-sales';
+import { CampaignsBlockConfig, ListCampaignsParams, Campaign, CreateCampaignRequest, UpdateCampaignRequest, CampaignResults, ListCampaignMediaParams, CampaignMedia, CreateCampaignMediaRequest, UpdateCampaignMediaRequest, CampaignMediaResults, ListLandingPagesParams, LandingPage, CreateLandingPageRequest, UpdateLandingPageRequest, ListAudiencesParams, Audience, CreateAudienceRequest, UpdateAudienceRequest, AudienceMember, ListLandingTemplatesParams, LandingTemplate, CreateLandingTemplateRequest, UpdateLandingTemplateRequest, ListCampaignTargetsParams, CampaignTarget, CreateCampaignTargetRequest, UpdateCampaignTargetRequest, ListCampaignResultsParams, CampaignResult, CreateCampaignResultRequest, UpdateCampaignResultRequest, ListCampaignMarketsParams, CampaignMarket, CreateCampaignMarketRequest, UpdateCampaignMarketRequest, ListCampaignLocationsParams, CampaignLocation, CreateCampaignLocationRequest, UpdateCampaignLocationRequest, ListCampaignTemplatesParams, CampaignTemplate, CreateCampaignTemplateRequest, UpdateCampaignTemplateRequest, ListTemplateDetailsParams, TemplateDetail, CreateTemplateDetailRequest, UpdateTemplateDetailRequest, ListCampaignMediaResultsParams, CampaignMediaResult, CreateCampaignMediaResultRequest, UpdateCampaignMediaResultRequest, ListMediaParams, Media, CreateMediaRequest, UpdateMediaRequest, CampaignsBlock } from '@23blocks/block-campaigns';
+import { CompanyBlockConfig, ListCompaniesParams, Company as Company$1, CreateCompanyRequest, UpdateCompanyRequest, ListDepartmentsParams, Department, CreateDepartmentRequest, UpdateDepartmentRequest, DepartmentHierarchy, ListTeamsParams, Team, CreateTeamRequest, UpdateTeamRequest, ListTeamMembersParams, TeamMember, AddTeamMemberRequest, UpdateTeamMemberRequest, ListQuartersParams, Quarter, CreateQuarterRequest, UpdateQuarterRequest, ListPositionsParams, Position, CreatePositionRequest, UpdatePositionRequest, ListEmployeeAssignmentsParams, EmployeeAssignment, CreateEmployeeAssignmentRequest, UpdateEmployeeAssignmentRequest, CompanyBlock } from '@23blocks/block-company';
+import { RewardsBlockConfig, ListRewardsParams, Reward, CreateRewardRequest, UpdateRewardRequest, RedeemRewardRequest, RewardRedemption, ListCouponsParams, Coupon, CreateCouponRequest, UpdateCouponRequest, ValidateCouponRequest, CouponValidationResult, ApplyCouponRequest, CouponApplication, Loyalty, AddPointsRequest, LoyaltyTransaction, RedeemPointsRequest, ListTransactionsParams, ListBadgesParams, Badge, CreateBadgeRequest, UpdateBadgeRequest, AwardBadgeRequest, UserBadge, ListUserBadgesParams, ListCouponConfigurationsParams, CouponConfiguration, CreateCouponConfigurationRequest, UpdateCouponConfigurationRequest, OfferCode, CreateOfferCodeRequest, SendOfferCodeRequest, RedeemOfferCodeRequest, ListExpirationRulesParams, ExpirationRule, CreateExpirationRuleRequest, UpdateExpirationRuleRequest, ListRewardsCustomersParams, RewardsCustomer, CustomerRewardExpiration, CustomerRewardHistory, BadgeCategory, CreateBadgeCategoryRequest, MoneyRule, CreateMoneyRuleRequest, UpdateMoneyRuleRequest, ProductRule, CreateProductRuleRequest, UpdateProductRuleRequest, EventRule, CreateEventRuleRequest, UpdateEventRuleRequest, RewardsBlock } from '@23blocks/block-rewards';
+import { JarvisBlockConfig, ListAgentsParams, Agent, CreateAgentRequest, UpdateAgentRequest, ChatRequest, ChatResponse, CompleteRequest, CompleteResponse, ListPromptsParams, Prompt, CreatePromptRequest, UpdatePromptRequest, ExecutePromptRequest, ExecutePromptResponse, TestPromptRequest, TestPromptResponse, RenderPromptRequest, RenderPromptResponse, ListWorkflowsParams, Workflow, CreateWorkflowRequest, UpdateWorkflowRequest, RunWorkflowRequest, RunWorkflowResponse, ListExecutionsParams, Execution, ListConversationsParams, Conversation as Conversation$1, CreateConversationRequest, SendMessageRequest, SendMessageResponse, ListAIModelsParams, AIModel, CreateAIModelRequest, UpdateAIModelRequest, ListEntitiesParams as ListEntitiesParams$1, Entity, RegisterEntityRequest as RegisterEntityRequest$1, UpdateEntityRequest as UpdateEntityRequest$1, EntityContext, CreateEntityContextRequest, SendEntityMessageRequest, SendEntityMessageResponse, QueryEntityFileRequest, QueryEntityFileResponse, ListClustersParams, Cluster, CreateClusterRequest, UpdateClusterRequest, ClusterContext, CreateClusterContextRequest, SendClusterMessageRequest, SendClusterMessageResponse, ListJarvisUsersParams, JarvisUser, RegisterJarvisUserRequest, UpdateJarvisUserRequest, UserContext, CreateUserContextRequest, SendUserMessageRequest, SendUserMessageResponse, CreateUserContentContextRequest, ListWorkflowParticipantsParams, WorkflowParticipant, AddWorkflowParticipantRequest, UpdateWorkflowParticipantRequest, WorkflowStep, AddWorkflowStepRequest, UpdateWorkflowStepRequest, AddStepPromptRequest, AddStepAgentRequest, StartWorkflowRequest, StartWorkflowResponse, WorkflowInstance, WorkflowInstanceDetails, StepWorkflowRequest, LogWorkflowStepRequest, AgentContext, CreateAgentContextRequest, AgentMessage, AgentThread, CreateAgentThreadRequest, SendAgentThreadMessageRequest, SendAgentThreadMessageResponse, RunAgentThreadRequest, RunAgentThreadResponse, AgentRun, ListAgentRunExecutionsParams, AgentRunExecution, ListMailTemplatesParams as ListMailTemplatesParams$1, MailTemplate as MailTemplate$2, CreateMailTemplateRequest as CreateMailTemplateRequest$1, UpdateMailTemplateRequest as UpdateMailTemplateRequest$1, CreateMandrillTemplateRequest as CreateMandrillTemplateRequest$1, UpdateMandrillTemplateRequest as UpdateMandrillTemplateRequest$1, MandrillStats, MarvinChatRequest, MarvinChatResponse, MarvinContext, CreateMarvinContextRequest, SendMarvinMessageRequest, SendMarvinMessageResponse, ListPromptCommentsParams, PromptComment, CreatePromptCommentRequest, UpdatePromptCommentRequest, ReplyToCommentRequest, ListExecutionCommentsParams, ExecutionComment, CreateExecutionCommentRequest, UpdateExecutionCommentRequest, JarvisBlock } from '@23blocks/block-jarvis';
+import { OnboardingBlockConfig, ListOnboardingsParams, Onboarding, CreateOnboardingRequest, UpdateOnboardingRequest, AddStepRequest, OnboardingStep, UpdateStepRequest, ListFlowsParams, Flow, CreateFlowRequest, UpdateFlowRequest, ListUserJourneysParams, UserJourney, StartJourneyRequest, CompleteStepRequest, UserJourneyReportParams, UserJourneyReportList, UserJourneyReportSummary, ListUserIdentitiesParams, UserIdentity, CreateUserIdentityRequest, VerifyUserIdentityRequest, StartOnboardRequest, OnboardJourney, OnboardJourneyDetails, StepOnboardRequest, LogOnboardRequest, ListMailTemplatesParams as ListMailTemplatesParams$2, MailTemplate as MailTemplate$3, CreateMailTemplateRequest as CreateMailTemplateRequest$2, UpdateMailTemplateRequest as UpdateMailTemplateRequest$2, MandrillTemplateStats as MandrillTemplateStats$1, CreateMandrillTemplateRequest as CreateMandrillTemplateRequest$2, UpdateMandrillTemplateRequest as UpdateMandrillTemplateRequest$2, ListAbandonedJourneysParams, AbandonedJourney, OnboardingBlock } from '@23blocks/block-onboarding';
+import { UniversityBlockConfig, ListCoursesParams, Course, CreateCourseRequest, UpdateCourseRequest, ListLessonsParams, Lesson, CreateLessonRequest, UpdateLessonRequest, ReorderLessonsRequest, ListEnrollmentsParams, Enrollment, EnrollRequest, UpdateEnrollmentProgressRequest, ListAssignmentsParams, Assignment, CreateAssignmentRequest, UpdateAssignmentRequest, ListSubmissionsParams, Submission, SubmitAssignmentRequest, GradeSubmissionRequest, ListSubjectsParams, Subject, CreateSubjectRequest, UpdateSubjectRequest, ListTeachersParams, Teacher, CourseGroup, TeacherAvailability, CreateAvailabilityRequest, UpdateAvailabilityRequest, ListStudentsParams, Student, RegisterStudentRequest, UpdateStudentRequest, StudentAvailability, CreateCourseGroupRequest, ListCoachingSessionsParams, CoachingSession, CreateCoachingSessionRequest, UpdateCoachingSessionRequest, ListContentTestsParams, ContentTest, CreateContentTestRequest, UpdateContentTestRequest, CreateQuestionRequest, TestQuestion, TestOption, CreateOptionRequest, ListRegistrationTokensParams, RegistrationToken, CreateRegistrationTokenRequest, UpdateRegistrationTokenRequest, TokenValidationResult, PlacementTest, ListPlacementsParams, CreatePlacementRequest, PlacementSection, CreatePlacementSectionRequest, PlacementQuestion, CreatePlacementQuestionRequest, PlacementOption, CreatePlacementOptionRequest, CreatePlacementRuleRequest, PlacementRule, PlacementInstance, PlacementResponse, Availability, BulkUpdateAvailabilityRequest, ListCalendarEventsParams, CalendarEvent, CreateCalendarEventRequest, UpdateCalendarEventRequest, CreateMatchRequest, Match, FindCoachesRequest, AvailableCoach, FindCoacheesRequest, AvailableCoachee, EvaluateMatchesRequest, MatchEvaluation, EvaluateAvailabilitiesRequest, ListAttendanceParams, Attendance, CreateAttendanceRequest, UpdateAttendanceRequest, BulkAttendanceRequest, AttendanceStats, ListNotesParams, Note, CreateNoteRequest, UpdateNoteRequest, UniversityBlock } from '@23blocks/block-university';
+import { WalletBlockConfig, ListWalletsParams, Wallet, CreateWalletRequest, UpdateWalletRequest, CreditWalletRequest, Transaction, DebitWalletRequest, ValidateWalletRequest, ValidateWalletResponse, TransferWalletRequest, WalletContent, StoreWalletContentRequest, ListTransactionsParams as ListTransactionsParams$1, ListAuthorizationCodesParams, AuthorizationCode, CreateAuthorizationCodeRequest, ValidateAuthorizationCodeRequest, UseAuthorizationCodeRequest, TransactionWebhookRequest, TransactionWebhookResponse, WalletBlock } from '@23blocks/block-wallet';
+import { Observable } from 'rxjs';
+
+/**
+ * Authentication mode
+ */
+type AuthMode = 'token' | 'cookie';
+/**
+ * Storage type for token mode
+ */
+type StorageType = 'localStorage' | 'sessionStorage' | 'memory';
+/**
+ * Service URL configuration - each microservice has its own URL.
+ * All URLs are optional - only configure the services you need.
+ */
+interface ServiceUrls {
+    /** Authentication service URL */
+    authentication?: string;
+    /** Search service URL */
+    search?: string;
+    /** Products service URL */
+    products?: string;
+    /** CRM service URL */
+    crm?: string;
+    /** Content service URL */
+    content?: string;
+    /** Geolocation service URL */
+    geolocation?: string;
+    /** Conversations service URL */
+    conversations?: string;
+    /** Files service URL */
+    files?: string;
+    /** Forms service URL */
+    forms?: string;
+    /** Assets service URL */
+    assets?: string;
+    /** Campaigns service URL */
+    campaigns?: string;
+    /** Company service URL */
+    company?: string;
+    /** Rewards service URL */
+    rewards?: string;
+    /** Sales service URL */
+    sales?: string;
+    /** Wallet service URL */
+    wallet?: string;
+    /** Jarvis (AI) service URL */
+    jarvis?: string;
+    /** Onboarding service URL */
+    onboarding?: string;
+    /** University (LMS) service URL */
+    university?: string;
+}
+/**
+ * Configuration for providing 23blocks services
+ */
+interface ProviderConfig {
+    /**
+     * Service URLs for each microservice.
+     * Only configure the services you need - accessing a service without
+     * a configured URL will throw an error.
+     *
+     * @example
+     * ```typescript
+     * provideBlocks23({
+     *   apiKey: 'your-api-key',
+     *   urls: {
+     *     authentication: 'https://gateway.23blocks.com',
+     *     crm: 'https://crm.23blocks.com',
+     *     products: 'https://products.23blocks.com',
+     *   },
+     * })
+     * ```
+     */
+    urls: ServiceUrls;
+    /**
+     * API Key for authenticating with 23blocks services
+     */
+    apiKey: string;
+    /**
+     * Tenant ID (optional, for multi-tenant setups)
+     */
+    tenantId?: string;
+    /**
+     * Authentication mode
+     * - 'token' (default): SDK stores tokens in localStorage/sessionStorage/memory
+     * - 'cookie': Backend manages auth via httpOnly cookies
+     */
+    authMode?: AuthMode;
+    /**
+     * Storage type for token mode
+     * @default 'localStorage'
+     */
+    storage?: StorageType;
+    /**
+     * Additional headers to include with every request
+     */
+    headers?: Record<string, string>;
+    /**
+     * Request timeout in milliseconds
+     * @default 30000
+     */
+    timeout?: number;
+}
+/**
+ * Injection token for the token manager (internal use)
+ */
+declare const TOKEN_MANAGER: InjectionToken<TokenManagerService>;
+/**
+ * Injection token for provider config
+ */
+declare const PROVIDER_CONFIG: InjectionToken<ProviderConfig>;
+/** @deprecated Use PROVIDER_CONFIG instead */
+declare const SIMPLE_CONFIG: InjectionToken<ProviderConfig>;
+/**
+ * Token manager interface
+ */
+interface TokenManagerService {
+    getAccessToken(): string | null;
+    getRefreshToken(): string | null;
+    setTokens(accessToken: string, refreshToken?: string): void;
+    clearTokens(): void;
+    /**
+     * Subscribe to storage changes from other tabs/windows.
+     * Returns an unsubscribe function.
+     */
+    onStorageChange(callback: () => void): () => void;
+}
+/**
+ * Provide 23blocks services with simplified configuration.
+ *
+ * This is the recommended way to set up 23blocks in new Angular applications.
+ * It automatically handles token storage and authentication headers.
+ *
+ * Services are only available if their URL is configured. Accessing a service
+ * without a configured URL will throw an error.
+ *
+ * @example Basic usage with multiple services
+ * ```typescript
+ * // app.config.ts
+ * import { ApplicationConfig } from '@angular/core';
+ * import { provideBlocks23 } from '@23blocks/angular';
+ *
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideBlocks23({
+ *       apiKey: 'your-api-key',
+ *       urls: {
+ *         authentication: 'https://gateway.23blocks.com',
+ *         crm: 'https://crm.23blocks.com',
+ *         products: 'https://products.23blocks.com',
+ *       },
+ *     }),
+ *   ],
+ * };
+ * ```
+ *
+ * @example Cookie mode (recommended for security)
+ * ```typescript
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideBlocks23({
+ *       apiKey: 'your-api-key',
+ *       authMode: 'cookie',
+ *       urls: {
+ *         authentication: 'https://gateway.23blocks.com',
+ *         crm: 'https://crm.23blocks.com',
+ *       },
+ *     }),
+ *   ],
+ * };
+ * ```
+ */
+declare function provideBlocks23(config: ProviderConfig): EnvironmentProviders;
+/**
+ * Get providers array for NgModule-based applications with simplified config.
+ *
+ * Services are only available if their URL is configured. Accessing a service
+ * without a configured URL will throw an error.
+ *
+ * @example
+ * ```typescript
+ * // app.module.ts
+ * import { NgModule } from '@angular/core';
+ * import { getBlocks23Providers } from '@23blocks/angular';
+ *
+ * @NgModule({
+ *   providers: [
+ *     ...getBlocks23Providers({
+ *       apiKey: 'your-api-key',
+ *       urls: {
+ *         authentication: 'https://gateway.23blocks.com',
+ *         crm: 'https://crm.23blocks.com',
+ *       },
+ *     }),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ */
+declare function getBlocks23Providers(config: ProviderConfig): Provider[];
+/** @deprecated Use `ProviderConfig` instead */
+type Simple23BlocksConfig = ProviderConfig;
+
+/**
+ * @deprecated Use per-service transport tokens (AUTHENTICATION_TRANSPORT, etc.)
+ * Shared transport token - only for backward compatibility with advanced API
+ */
+declare const TRANSPORT: InjectionToken<Transport>;
+/** Transport for Authentication service */
+declare const AUTHENTICATION_TRANSPORT: InjectionToken<Transport>;
+/** Transport for Search service */
+declare const SEARCH_TRANSPORT: InjectionToken<Transport>;
+/** Transport for Products service */
+declare const PRODUCTS_TRANSPORT: InjectionToken<Transport>;
+/** Transport for CRM service */
+declare const CRM_TRANSPORT: InjectionToken<Transport>;
+/** Transport for Content service */
+declare const CONTENT_TRANSPORT: InjectionToken<Transport>;
+/** Transport for Geolocation service */
+declare const GEOLOCATION_TRANSPORT: InjectionToken<Transport>;
+/** Transport for Conversations service */
+declare const CONVERSATIONS_TRANSPORT: InjectionToken<Transport>;
+/** Transport for Files service */
+declare const FILES_TRANSPORT: InjectionToken<Transport>;
+/** Transport for Forms service */
+declare const FORMS_TRANSPORT: InjectionToken<Transport>;
+/** Transport for Assets service */
+declare const ASSETS_TRANSPORT: InjectionToken<Transport>;
+/** Transport for Campaigns service */
+declare const CAMPAIGNS_TRANSPORT: InjectionToken<Transport>;
+/** Transport for Company service */
+declare const COMPANY_TRANSPORT: InjectionToken<Transport>;
+/** Transport for Rewards service */
+declare const REWARDS_TRANSPORT: InjectionToken<Transport>;
+/** Transport for Sales service */
+declare const SALES_TRANSPORT: InjectionToken<Transport>;
+/** Transport for Wallet service */
+declare const WALLET_TRANSPORT: InjectionToken<Transport>;
+/** Transport for Jarvis service */
+declare const JARVIS_TRANSPORT: InjectionToken<Transport>;
+/** Transport for Onboarding service */
+declare const ONBOARDING_TRANSPORT: InjectionToken<Transport>;
+/** Transport for University service */
+declare const UNIVERSITY_TRANSPORT: InjectionToken<Transport>;
+/**
+ * Injection token for Authentication block configuration
+ */
+declare const AUTHENTICATION_CONFIG: InjectionToken<AuthenticationBlockConfig>;
+/**
+ * Injection token for Search block configuration
+ */
+declare const SEARCH_CONFIG: InjectionToken<SearchBlockConfig>;
+/**
+ * Injection token for Geolocation block configuration
+ */
+declare const GEOLOCATION_CONFIG: InjectionToken<GeolocationBlockConfig>;
+/**
+ * Injection token for Content block configuration
+ */
+declare const CONTENT_CONFIG: InjectionToken<ContentBlockConfig>;
+/**
+ * Injection token for CRM block configuration
+ */
+declare const CRM_CONFIG: InjectionToken<CrmBlockConfig>;
+/**
+ * Injection token for Products block configuration
+ */
+declare const PRODUCTS_CONFIG: InjectionToken<ProductsBlockConfig>;
+/**
+ * Injection token for Conversations block configuration
+ */
+declare const CONVERSATIONS_CONFIG: InjectionToken<ConversationsBlockConfig>;
+/**
+ * Injection token for Files block configuration
+ */
+declare const FILES_CONFIG: InjectionToken<FilesBlockConfig>;
+/**
+ * Injection token for Assets block configuration
+ */
+declare const ASSETS_CONFIG: InjectionToken<AssetsBlockConfig>;
+/**
+ * Injection token for Forms block configuration
+ */
+declare const FORMS_CONFIG: InjectionToken<FormsBlockConfig>;
+/**
+ * Injection token for Sales block configuration
+ */
+declare const SALES_CONFIG: InjectionToken<SalesBlockConfig>;
+/**
+ * Injection token for Campaigns block configuration
+ */
+declare const CAMPAIGNS_CONFIG: InjectionToken<CampaignsBlockConfig>;
+/**
+ * Injection token for Company block configuration
+ */
+declare const COMPANY_CONFIG: InjectionToken<CompanyBlockConfig>;
+/**
+ * Injection token for Rewards block configuration
+ */
+declare const REWARDS_CONFIG: InjectionToken<RewardsBlockConfig>;
+/**
+ * Injection token for Jarvis block configuration
+ */
+declare const JARVIS_CONFIG: InjectionToken<JarvisBlockConfig>;
+/**
+ * Injection token for Onboarding block configuration
+ */
+declare const ONBOARDING_CONFIG: InjectionToken<OnboardingBlockConfig>;
+/**
+ * Injection token for University block configuration
+ */
+declare const UNIVERSITY_CONFIG: InjectionToken<UniversityBlockConfig>;
+/**
+ * Injection token for Wallet block configuration
+ */
+declare const WALLET_CONFIG: InjectionToken<WalletBlockConfig>;
+
+/**
+ * Configuration for providing 23blocks services
+ */
+interface Provide23BlocksConfig {
+    transport: Transport;
+    authentication?: AuthenticationBlockConfig;
+    search?: SearchBlockConfig;
+    products?: ProductsBlockConfig;
+    crm?: CrmBlockConfig;
+    content?: ContentBlockConfig;
+    geolocation?: GeolocationBlockConfig;
+    conversations?: ConversationsBlockConfig;
+    files?: FilesBlockConfig;
+    forms?: FormsBlockConfig;
+    assets?: AssetsBlockConfig;
+    campaigns?: CampaignsBlockConfig;
+    company?: CompanyBlockConfig;
+    rewards?: RewardsBlockConfig;
+    sales?: SalesBlockConfig;
+    wallet?: WalletBlockConfig;
+    jarvis?: JarvisBlockConfig;
+    onboarding?: OnboardingBlockConfig;
+    university?: UniversityBlockConfig;
+}
+/**
+ * Provide 23blocks services for standalone Angular applications.
+ *
+ * @example
+ * ```typescript
+ * // app.config.ts
+ * import { ApplicationConfig } from '@angular/core';
+ * import { provide23Blocks } from '@23blocks/angular';
+ * import { createHttpTransport } from '@23blocks/transport-http';
+ *
+ * const transport = createHttpTransport({
+ *   baseUrl: 'https://api.example.com',
+ *   headers: () => ({
+ *     'Authorization': `Bearer ${localStorage.getItem('token')}`,
+ *   }),
+ * });
+ *
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provide23Blocks({
+ *       transport,
+ *       authentication: { apiKey: 'my-api-key' },
+ *       search: { apiKey: 'my-api-key' },
+ *       products: { apiKey: 'my-api-key' },
+ *       crm: { apiKey: 'my-api-key' },
+ *     }),
+ *   ],
+ * };
+ * ```
+ */
+declare function provide23Blocks(config: Provide23BlocksConfig): EnvironmentProviders;
+/**
+ * Get providers array for NgModule-based applications.
+ *
+ * @example
+ * ```typescript
+ * // app.module.ts
+ * import { NgModule } from '@angular/core';
+ * import { get23BlocksProviders } from '@23blocks/angular';
+ *
+ * @NgModule({
+ *   providers: [
+ *     ...get23BlocksProviders({
+ *       transport,
+ *       authentication: { apiKey: 'my-api-key' },
+ *     }),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ */
+declare function get23BlocksProviders(config: Provide23BlocksConfig): Provider[];
+
+/**
+ * Angular service wrapping the Authentication block.
+ * Converts Promise-based APIs to RxJS Observables.
+ *
+ * @example
+ * ```typescript
+ * @Component({...})
+ * export class LoginComponent {
+ *   constructor(private auth: AuthenticationService) {}
+ *
+ *   login(email: string, password: string) {
+ *     this.auth.signIn({ email, password }).subscribe({
+ *       next: (response) => console.log('Signed in:', response.user),
+ *       error: (err) => console.error('Failed:', err),
+ *     });
+ *   }
+ * }
+ * ```
+ */
+declare class AuthenticationService {
+    private readonly block;
+    private readonly tokenManager;
+    private readonly simpleConfig;
+    constructor(serviceTransport: Transport | null, legacyTransport: Transport | null, config: AuthenticationBlockConfig, tokenManager: TokenManagerService | null, simpleConfig: Simple23BlocksConfig | null);
+    /**
+     * Ensure the service is configured, throw helpful error if not
+     */
+    private ensureConfigured;
+    /**
+     * Check if using simplified API with automatic token management
+     */
+    private get isTokenMode();
+    /**
+     * Sign in with email and password.
+     * When using simplified API (provideBlocks23), tokens are stored automatically.
+     */
+    signIn(request: SignInRequest): Observable<SignInResponse>;
+    /**
+     * Sign up a new user.
+     * When using simplified API, tokens are stored automatically if returned.
+     */
+    signUp(request: SignUpRequest): Observable<SignUpResponse>;
+    /**
+     * Sign out the current user.
+     * When using simplified API, tokens are cleared automatically.
+     */
+    signOut(): Observable<void>;
+    requestPasswordReset(request: PasswordResetRequest): Observable<void>;
+    updatePassword(request: PasswordUpdateRequest): Observable<void>;
+    validateToken(token: string): Observable<TokenValidationResponse>;
+    getCurrentUser(): Observable<User | null>;
+    /**
+     * Refresh the access token
+     */
+    refreshToken(request: RefreshTokenRequest): Observable<RefreshTokenResponse>;
+    /**
+     * Request a magic link for passwordless login
+     */
+    requestMagicLink(request: MagicLinkRequest): Observable<void>;
+    /**
+     * Verify a magic link token
+     */
+    verifyMagicLink(request: MagicLinkVerifyRequest): Observable<SignInResponse>;
+    /**
+     * Send an invitation to a new user
+     */
+    sendInvitation(request: InvitationRequest): Observable<void>;
+    /**
+     * Accept an invitation
+     */
+    acceptInvitation(request: AcceptInvitationRequest): Observable<SignInResponse>;
+    /**
+     * Confirm email with token
+     */
+    confirmEmail(token: string): Observable<User>;
+    /**
+     * Resend confirmation email
+     */
+    resendConfirmation(request: ResendConfirmationRequest): Observable<void>;
+    /**
+     * Validate email before registration
+     */
+    validateEmail(request: ValidateEmailRequest): Observable<ValidateEmailResponse>;
+    /**
+     * Validate document before registration
+     */
+    validateDocument(request: ValidateDocumentRequest): Observable<ValidateDocumentResponse>;
+    /**
+     * Resend invitation email
+     */
+    resendInvitation(request: ResendInvitationRequest): Observable<User>;
+    /**
+     * Request account recovery (for deleted accounts)
+     */
+    requestAccountRecovery(request: AccountRecoveryRequest): Observable<AccountRecoveryResponse>;
+    /**
+     * Complete account recovery with new password
+     */
+    completeAccountRecovery(request: CompleteRecoveryRequest): Observable<User>;
+    listUsers(params?: {
+        page?: number;
+        perPage?: number;
+    }): Observable<User[]>;
+    getUser(id: string): Observable<User>;
+    updateUser(id: string, request: UpdateUserRequest): Observable<User>;
+    deleteUser(id: string): Observable<void>;
+    /**
+     * Get a user by unique ID
+     */
+    getUserByUniqueId(uniqueId: string): Observable<User>;
+    /**
+     * Update user profile
+     */
+    updateUserProfile(userId: string, request: UpdateProfileRequest): Observable<User>;
+    /**
+     * Activate a user
+     */
+    activateUser(id: string): Observable<User>;
+    /**
+     * Deactivate a user
+     */
+    deactivateUser(id: string): Observable<User>;
+    /**
+     * Change user role
+     */
+    changeUserRole(id: string, roleUniqueId: string, reason: string, forceReauth?: boolean): Observable<User>;
+    /**
+     * Search users by query
+     */
+    searchUsers(query: string, params?: ListParams): Observable<PageResult<User>>;
+    /**
+     * Advanced search users by criteria or payload
+     */
+    searchUsersAdvanced(request: UserSearchRequest, params?: ListParams): Observable<PageResult<User>>;
+    /**
+     * Get user profile
+     */
+    getUserProfile(userUniqueId: string): Observable<UserProfileFull>;
+    /**
+     * Create or update user profile
+     */
+    createUserProfile(request: ProfileRequest): Observable<UserProfileFull>;
+    /**
+     * Update email address
+     */
+    updateUserEmail(userUniqueId: string, request: UpdateEmailRequest): Observable<User>;
+    /**
+     * Get user devices
+     */
+    getUserDevices(userUniqueId: string, params?: ListParams): Observable<PageResult<UserDeviceFull>>;
+    /**
+     * Add a device
+     */
+    addUserDevice(request: AddDeviceRequest): Observable<UserDeviceFull>;
+    /**
+     * Get user's companies
+     */
+    getUserCompanies(userUniqueId: string): Observable<Company[]>;
+    /**
+     * Add subscription to user
+     */
+    addUserSubscription(userUniqueId: string, request: AddUserSubscriptionRequest): Observable<UserSubscription>;
+    /**
+     * Update user subscription
+     */
+    updateUserSubscription(userUniqueId: string, request: AddUserSubscriptionRequest): Observable<UserSubscription>;
+    /**
+     * Resend confirmation email by user unique ID
+     */
+    resendConfirmationByUniqueId(userUniqueId: string): Observable<void>;
+    listRoles(): Observable<Role[]>;
+    getRole(id: string): Observable<Role>;
+    createRole(request: CreateRoleRequest): Observable<Role>;
+    updateRole(id: string, request: UpdateRoleRequest): Observable<Role>;
+    deleteRole(id: string): Observable<void>;
+    listPermissions(): Observable<Permission[]>;
+    /**
+     * List all permissions with pagination
+     */
+    listPermissionsPaginated(params?: ListParams): Observable<PageResult<Permission>>;
+    /**
+     * Get a permission by ID
+     */
+    getPermission(id: string): Observable<Permission>;
+    /**
+     * Create a new permission
+     */
+    createPermission(request: CreatePermissionRequest): Observable<Permission>;
+    /**
+     * Update a permission
+     */
+    updatePermission(id: string, request: UpdatePermissionRequest): Observable<Permission>;
+    /**
+     * Delete a permission
+     */
+    deletePermission(id: string): Observable<void>;
+    listApiKeys(): Observable<ApiKey[]>;
+    getApiKey(id: string): Observable<ApiKey>;
+    createApiKey(request: CreateApiKeyRequest): Observable<ApiKeyWithSecret>;
+    updateApiKey(id: string, request: UpdateApiKeyRequest): Observable<ApiKey>;
+    revokeApiKey(id: string): Observable<void>;
+    /**
+     * Initialize MFA setup - generates secret, QR code, and backup codes
+     */
+    mfaSetup(): Observable<MfaSetupResponseFull>;
+    /**
+     * Enable MFA after verifying setup with TOTP code
+     */
+    mfaEnable(request: MfaEnableRequest): Observable<MfaOperationResponse>;
+    /**
+     * Disable MFA with password confirmation
+     */
+    mfaDisable(request: MfaDisableRequest): Observable<MfaOperationResponse>;
+    /**
+     * Verify MFA code during login
+     */
+    mfaVerify(request: MfaVerifyRequestFull): Observable<MfaVerificationResponse>;
+    /**
+     * Get current MFA status
+     */
+    mfaStatus(): Observable<MfaStatusResponse>;
+    /**
+     * Login with Facebook OAuth token
+     */
+    loginWithFacebook(request: OAuthSocialLoginRequest): Observable<SignInResponse>;
+    /**
+     * Login with Google OAuth token
+     */
+    loginWithGoogle(request: OAuthSocialLoginRequest): Observable<SignInResponse>;
+    /**
+     * Login to a specific tenant
+     */
+    loginWithTenant(request: TenantLoginRequest): Observable<SignInResponse>;
+    /**
+     * Introspect a token to validate and get information
+     */
+    introspectToken(token: string): Observable<TokenIntrospectionResponse>;
+    /**
+     * Revoke a specific token
+     */
+    revokeToken(request: TokenRevokeRequest): Observable<TokenRevokeResponse>;
+    /**
+     * Revoke all tokens for the current user
+     */
+    revokeAllTokens(request?: TokenRevokeAllRequest): Observable<TokenRevokeResponse>;
+    /**
+     * Create a tenant context (switch to a different tenant)
+     */
+    createTenantContext(request: TenantContextCreateRequest): Observable<TenantContextResponse>;
+    /**
+     * Revoke tenant context (exit tenant switch)
+     */
+    revokeTenantContext(): Observable<void>;
+    /**
+     * Get tenant context audit log
+     */
+    auditTenantContext(): Observable<TenantContextAuditEntry[]>;
+    /**
+     * List avatars for a user
+     */
+    listAvatars(userUniqueId: string, params?: ListParams): Observable<PageResult<UserAvatarFull>>;
+    /**
+     * Get a specific avatar
+     */
+    getAvatar(userUniqueId: string): Observable<UserAvatarFull>;
+    /**
+     * Create/update an avatar
+     */
+    createAvatar(userUniqueId: string, request: CreateAvatarRequest): Observable<UserAvatarFull>;
+    /**
+     * Update an avatar
+     */
+    updateAvatar(userUniqueId: string, request: Partial<CreateAvatarRequest>): Observable<UserAvatarFull>;
+    /**
+     * Delete an avatar
+     */
+    deleteAvatar(userUniqueId: string): Observable<void>;
+    /**
+     * Get presigned URL for direct upload
+     */
+    presignAvatarUpload(userUniqueId: string, filename: string): Observable<AvatarPresignResponse>;
+    /**
+     * Get presigned URLs for multipart upload
+     */
+    multipartAvatarPresign(userUniqueId: string, request: MultipartPresignRequest): Observable<MultipartPresignResponse>;
+    /**
+     * Complete a multipart upload
+     */
+    multipartAvatarComplete(userUniqueId: string, request: MultipartCompleteRequest): Observable<MultipartCompleteResponse>;
+    /**
+     * List child tenants
+     */
+    listChildTenants(params?: ListParams): Observable<PageResult<Company>>;
+    /**
+     * Validate tenant code availability
+     */
+    validateTenantCode(request: ValidateTenantCodeRequest): Observable<ValidateTenantCodeResponse>;
+    /**
+     * Search for a tenant by name
+     */
+    searchTenantByName(request: SearchTenantRequest): Observable<Company>;
+    /**
+     * Search for a tenant by code
+     */
+    searchTenantByCode(request: SearchTenantRequest): Observable<Company>;
+    /**
+     * Create a tenant user relationship
+     */
+    createTenantUser(userUniqueId: string, request: CreateTenantUserRequest): Observable<TenantUserFull>;
+    /**
+     * Update tenant user onboarding status
+     */
+    updateTenantUserOnboarding(userUniqueId: string, urlId: string, request: UpdateTenantUserOnboardingRequest): Observable<TenantUserFull>;
+    /**
+     * Update tenant user sales/purchase status
+     */
+    updateTenantUserSales(userUniqueId: string, urlId: string, request: UpdateTenantUserSalesRequest): Observable<TenantUserFull>;
+    /**
+     * List apps with pagination
+     */
+    listApps(params?: ListParams): Observable<PageResult<App>>;
+    /**
+     * Get an app by ID
+     */
+    getApp(id: string): Observable<App>;
+    /**
+     * Create a new app
+     */
+    createApp(request: CreateAppRequest): Observable<App>;
+    /**
+     * Update an app
+     */
+    updateApp(id: string, request: UpdateAppRequest): Observable<App>;
+    /**
+     * Delete an app
+     */
+    deleteApp(id: string): Observable<void>;
+    /**
+     * Regenerate webhook secret for an app
+     */
+    regenerateAppWebhookSecret(id: string): Observable<App>;
+    /**
+     * List blocks for a company
+     */
+    listBlocks(companyId: string, params?: ListParams): Observable<PageResult<Block>>;
+    /**
+     * Get a block by ID
+     */
+    getBlock(id: string): Observable<Block>;
+    /**
+     * Add a block to a company
+     */
+    addBlock(companyId: string, blockCode: string): Observable<Block>;
+    /**
+     * Remove a block from a company
+     */
+    removeBlock(id: string): Observable<void>;
+    /**
+     * List registered services
+     */
+    listServices(params?: ListParams): Observable<PageResult<Service>>;
+    /**
+     * Get a service by ID
+     */
+    getService(id: string): Observable<Service>;
+    /**
+     * Get a service by code
+     */
+    getServiceByCode(code: string): Observable<Service>;
+    /**
+     * Health check all services
+     */
+    healthCheckServices(): Observable<Service[]>;
+    /**
+     * List subscription models
+     */
+    listSubscriptionModels(params?: ListParams): Observable<PageResult<SubscriptionModel>>;
+    /**
+     * Get a subscription model by ID
+     */
+    getSubscriptionModel(id: string): Observable<SubscriptionModel>;
+    /**
+     * Get a subscription model by code
+     */
+    getSubscriptionModelByCode(code: string): Observable<SubscriptionModel>;
+    /**
+     * List promotional subscription models
+     */
+    listPromotionalSubscriptionModels(): Observable<SubscriptionModel[]>;
+    /**
+     * List user subscriptions
+     */
+    listUserSubscriptions(params?: ListParams): Observable<PageResult<UserSubscription>>;
+    /**
+     * Get a user subscription by ID
+     */
+    getUserSubscription(id: string): Observable<UserSubscription>;
+    /**
+     * Get subscriptions for a user
+     */
+    getSubscriptionsForUser(userUniqueId: string): Observable<UserSubscription[]>;
+    /**
+     * Subscribe a user to a plan
+     */
+    subscribeUser(userUniqueId: string, request: SubscribeRequest): Observable<UserSubscription>;
+    /**
+     * Cancel a user subscription
+     */
+    cancelUserSubscription(id: string): Observable<UserSubscription>;
+    /**
+     * Reactivate a user subscription
+     */
+    reactivateUserSubscription(id: string): Observable<UserSubscription>;
+    /**
+     * List company subscriptions
+     */
+    listCompanySubscriptions(params?: ListParams): Observable<PageResult<CompanySubscription>>;
+    /**
+     * Get a company subscription by ID
+     */
+    getCompanySubscription(id: string): Observable<CompanySubscription>;
+    /**
+     * Get subscriptions for a company
+     */
+    getSubscriptionsForCompany(companyUniqueId: string): Observable<CompanySubscription[]>;
+    /**
+     * Subscribe a company to a plan
+     */
+    subscribeCompany(companyUniqueId: string, request: SubscribeRequest): Observable<CompanySubscription>;
+    /**
+     * Cancel a company subscription
+     */
+    cancelCompanySubscription(id: string): Observable<CompanySubscription>;
+    /**
+     * Reactivate a company subscription
+     */
+    reactivateCompanySubscription(id: string): Observable<CompanySubscription>;
+    /**
+     * List countries with pagination
+     */
+    listCountries(params?: ListParams): Observable<PageResult<Country>>;
+    /**
+     * Get a country by ID
+     */
+    getCountry(id: string): Observable<Country>;
+    /**
+     * Get a country by ISO code
+     */
+    getCountryByIsoCode(isoCode: string): Observable<Country>;
+    /**
+     * Get all countries (no pagination)
+     */
+    getAllCountries(): Observable<Country[]>;
+    /**
+     * List states with pagination
+     */
+    listStates(params?: ListParams): Observable<PageResult<State>>;
+    /**
+     * Get a state by ID
+     */
+    getState(id: string): Observable<State>;
+    /**
+     * Get states for a country
+     */
+    getStatesForCountry(countryId: string): Observable<State[]>;
+    /**
+     * List counties with pagination
+     */
+    listCounties(params?: ListParams): Observable<PageResult<County>>;
+    /**
+     * Get a county by ID
+     */
+    getCounty(id: string): Observable<County>;
+    /**
+     * Get counties for a state
+     */
+    getCountiesForState(stateId: string): Observable<County[]>;
+    /**
+     * List cities with pagination
+     */
+    listCities(params?: ListParams): Observable<PageResult<City>>;
+    /**
+     * Get a city by ID
+     */
+    getCity(id: string): Observable<City>;
+    /**
+     * Get cities for a state
+     */
+    getCitiesForState(stateId: string): Observable<City[]>;
+    /**
+     * Get cities for a county
+     */
+    getCitiesForCounty(countyId: string): Observable<City[]>;
+    /**
+     * Search cities by name
+     */
+    searchCities(query: string, params?: ListParams): Observable<PageResult<City>>;
+    /**
+     * List currencies with pagination
+     */
+    listCurrencies(params?: ListParams): Observable<PageResult<Currency>>;
+    /**
+     * Get a currency by ID
+     */
+    getCurrency(id: string): Observable<Currency>;
+    /**
+     * Get a currency by code
+     */
+    getCurrencyByCode(code: string): Observable<Currency>;
+    /**
+     * Get all currencies (no pagination)
+     */
+    getAllCurrencies(): Observable<Currency[]>;
+    /**
+     * List guests with pagination
+     */
+    listGuests(params?: ListParams): Observable<PageResult<Guest>>;
+    /**
+     * Get a guest by ID
+     */
+    getGuest(id: string): Observable<Guest>;
+    /**
+     * Track a guest visit
+     */
+    trackGuest(): Observable<Guest>;
+    /**
+     * Convert guest to user (registration)
+     */
+    convertGuest(id: string): Observable<Guest>;
+    /**
+     * List magic links with pagination
+     */
+    listMagicLinks(params?: ListParams): Observable<PageResult<MagicLink>>;
+    /**
+     * Get a magic link by ID
+     */
+    getMagicLink(id: string): Observable<MagicLink>;
+    /**
+     * Create a magic link
+     */
+    createMagicLink(request: CreateMagicLinkRequest): Observable<MagicLink>;
+    /**
+     * Validate a magic link token
+     */
+    validateMagicLink(token: string): Observable<MagicLink>;
+    /**
+     * Expire a magic link
+     */
+    expireMagicLink(id: string): Observable<MagicLink>;
+    /**
+     * List refresh tokens for the current user
+     */
+    listRefreshTokens(params?: ListParams): Observable<PageResult<RefreshToken>>;
+    /**
+     * Revoke a refresh token
+     */
+    revokeRefreshToken(id: string): Observable<RefreshToken>;
+    /**
+     * Revoke all refresh tokens for current user
+     */
+    revokeAllRefreshTokens(): Observable<void>;
+    /**
+     * Revoke all refresh tokens except current
+     */
+    revokeOtherRefreshTokens(): Observable<void>;
+    /**
+     * List devices for current user
+     */
+    listDevices(params?: ListParams): Observable<PageResult<UserDevice>>;
+    /**
+     * Get a device by ID
+     */
+    getDevice(id: string): Observable<UserDevice>;
+    /**
+     * Register a new device
+     */
+    registerDevice(request: RegisterDeviceRequest): Observable<UserDevice>;
+    /**
+     * Update device settings
+     */
+    updateDevice(id: string, request: Partial<RegisterDeviceRequest>): Observable<UserDevice>;
+    /**
+     * Unregister a device
+     */
+    unregisterDevice(id: string): Observable<void>;
+    /**
+     * Set default device
+     */
+    setDefaultDevice(id: string): Observable<UserDevice>;
+    /**
+     * Get current tenant user context
+     */
+    getCurrentTenantUser(): Observable<TenantUser>;
+    /**
+     * Get tenant user by user ID
+     */
+    getTenantUser(userUniqueId: string): Observable<TenantUser>;
+    /**
+     * List tenant users
+     */
+    listTenantUsers(params?: ListParams): Observable<TenantUser[]>;
+    /**
+     * List mail templates with pagination
+     */
+    listMailTemplates(params?: ListParams): Observable<PageResult<MailTemplate>>;
+    /**
+     * Get a mail template by ID
+     */
+    getMailTemplate(id: string): Observable<MailTemplate>;
+    /**
+     * Get a mail template by event name
+     */
+    getMailTemplateByEvent(eventName: string): Observable<MailTemplate>;
+    /**
+     * Update a mail template
+     */
+    updateMailTemplate(id: string, template: Partial<MailTemplate>): Observable<MailTemplate>;
+    /**
+     * Get the current access token (token mode only).
+     * Returns null if using cookie mode or no token is stored.
+     */
+    getAccessToken(): string | null;
+    /**
+     * Manually set tokens (token mode only).
+     * Useful for SSR hydration or external auth flows.
+     */
+    setTokens(accessToken: string, refreshToken?: string): void;
+    /**
+     * Clear stored tokens.
+     */
+    clearTokens(): void;
+    /**
+     * Check if user is likely authenticated.
+     * In token mode: checks if token exists.
+     * In cookie mode: always returns null (use validateToken instead).
+     */
+    isAuthenticated(): boolean | null;
+    /**
+     * Get the JSON Web Key Set (JWKS) for verifying tokens
+     */
+    getJwks(): Observable<JwksResponse>;
+    /**
+     * List all RSA keys
+     */
+    listRsaKeys(): Observable<RsaKey[]>;
+    /**
+     * Create a new RSA key
+     */
+    createRsaKey(request: CreateRsaKeyRequest): Observable<RsaKey>;
+    /**
+     * Rotate an RSA key (creates new, deactivates old)
+     */
+    rotateRsaKey(kid: string, request?: RotateRsaKeyRequest): Observable<RsaKey>;
+    /**
+     * Delete an RSA key
+     */
+    deleteRsaKey(kid: string): Observable<void>;
+    /**
+     * Get OpenID Connect discovery document
+     */
+    getOidcDiscovery(): Observable<OidcDiscovery>;
+    /**
+     * Get authorization endpoint URL with parameters
+     */
+    getOidcAuthorizeUrl(request: OidcAuthorizeRequest): string;
+    /**
+     * Exchange authorization code for tokens
+     */
+    exchangeOidcToken(request: OidcTokenRequest): Observable<OidcTokenResponse>;
+    /**
+     * Get user info from OIDC userinfo endpoint
+     */
+    getOidcUserInfo(accessToken: string): Observable<OidcUserInfo>;
+    /**
+     * Access the underlying block for advanced operations
+     * Use this when you need access to services not wrapped by this Angular service
+     */
+    get authenticationBlock(): AuthenticationBlock;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthenticationService, [{ optional: true; }, { optional: true; }, null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthenticationService>;
+}
+
+/**
+ * Angular service wrapping the Search block.
+ * Converts Promise-based APIs to RxJS Observables.
+ *
+ * @example
+ * ```typescript
+ * @Component({...})
+ * export class SearchComponent {
+ *   results$ = new BehaviorSubject<SearchResult[]>([]);
+ *
+ *   constructor(private searchService: SearchService) {}
+ *
+ *   onSearch(query: string) {
+ *     this.searchService.search({ query }).subscribe({
+ *       next: (response) => this.results$.next(response.results),
+ *       error: (err) => console.error('Search failed:', err),
+ *     });
+ *   }
+ * }
+ * ```
+ */
+declare class SearchService {
+    private readonly block;
+    constructor(serviceTransport: Transport | null, legacyTransport: Transport | null, config: SearchBlockConfig);
+    /**
+     * Ensure the service is configured, throw helpful error if not
+     */
+    private ensureConfigured;
+    /**
+     * Perform a search query
+     */
+    search(request: SearchRequest): Observable<SearchResponse>;
+    /**
+     * Get search suggestions for autocomplete
+     */
+    suggest(query: string, limit?: number): Observable<SearchResult[]>;
+    /**
+     * Get available entity types for filtering
+     */
+    getEntityTypes(): Observable<EntityType[]>;
+    /**
+     * Get recent search queries
+     */
+    getLastQueries(limit?: number): Observable<LastQuery[]>;
+    /**
+     * Get the full history of search queries
+     */
+    getQueryHistory(params?: {
+        page?: number;
+        perPage?: number;
+    }): Observable<SearchQuery[]>;
+    /**
+     * Clear search history
+     */
+    clearHistory(): Observable<void>;
+    /**
+     * List user's favorite entities
+     */
+    listFavorites(): Observable<FavoriteEntity[]>;
+    /**
+     * Add an entity to favorites
+     */
+    addFavorite(request: AddFavoriteRequest): Observable<FavoriteEntity>;
+    /**
+     * Remove an entity from favorites
+     */
+    removeFavorite(id: string): Observable<void>;
+    /**
+     * Check if an entity is favorited
+     */
+    isFavorite(entityUniqueId: string): Observable<boolean>;
+    listEntities(params?: ListEntitiesParams): Observable<PageResult<SearchEntity>>;
+    getEntity(uniqueId: string): Observable<SearchEntity>;
+    registerEntity(uniqueId: string, data: RegisterEntityRequest): Observable<SearchEntity>;
+    updateEntity(uniqueId: string, data: UpdateEntityRequest): Observable<SearchEntity>;
+    deleteEntity(uniqueId: string): Observable<void>;
+    listRegisteredEntityTypes(): Observable<{
+        entityType: string;
+    }[]>;
+    getEntityTypeSchema(entityType: string): Observable<EntityTypeSchema>;
+    searchByCopilot(data: CopilotSearchRequest): Observable<SearchEntity[]>;
+    listIdentities(params?: ListIdentitiesParams): Observable<PageResult<SearchIdentity>>;
+    getIdentity(uniqueId: string): Observable<SearchIdentity>;
+    registerIdentity(uniqueId: string, data: RegisterIdentityRequest): Observable<SearchIdentity>;
+    updateIdentity(uniqueId: string, data: UpdateIdentityRequest): Observable<SearchIdentity>;
+    /**
+     * Perform AI-enhanced search using Jarvis
+     */
+    jarvisSearch(query: JarvisSearchQuery): Observable<PageResult<JarvisSearchResult>>;
+    /**
+     * Get semantic suggestions using Jarvis AI
+     */
+    jarvisSuggest(query: string, limit?: number): Observable<string[]>;
+    /**
+     * Get related entities using Jarvis AI
+     */
+    jarvisGetRelated(entityUniqueId: string, entityType: string, limit?: number): Observable<JarvisSearchResult[]>;
+    /**
+     * Access the underlying block for advanced operations
+     */
+    get searchBlock(): SearchBlock;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchService, [{ optional: true; }, { optional: true; }, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SearchService>;
+}
+
+/**
+ * Angular service wrapping the Products block.
+ * Converts Promise-based APIs to RxJS Observables.
+ *
+ * @example
+ * ```typescript
+ * @Component({...})
+ * export class ProductsComponent {
+ *   constructor(private products: ProductsService) {}
+ *
+ *   loadProducts() {
+ *     this.products.listProducts().subscribe({
+ *       next: (result) => console.log('Products:', result.data),
+ *       error: (err) => console.error('Failed:', err),
+ *     });
+ *   }
+ * }
+ * ```
+ */
+declare class ProductsService {
+    private readonly block;
+    constructor(serviceTransport: Transport | null, legacyTransport: Transport | null, config: ProductsBlockConfig);
+    /**
+     * Ensure the service is configured, throw helpful error if not
+     */
+    private ensureConfigured;
+    listProducts(params?: ListProductsParams): Observable<PageResult<Product>>;
+    getProduct(uniqueId: string): Observable<Product>;
+    createProduct(data: CreateProductRequest): Observable<Product>;
+    updateProduct(uniqueId: string, data: UpdateProductRequest): Observable<Product>;
+    deleteProduct(uniqueId: string): Observable<void>;
+    recoverProduct(uniqueId: string): Observable<Product>;
+    searchProducts(query: string, params?: ListProductsParams): Observable<PageResult<Product>>;
+    listDeletedProducts(params?: ListProductsParams): Observable<PageResult<Product>>;
+    listVariations(productUniqueId: string): Observable<ProductVariation[]>;
+    getVariation(uniqueId: string): Observable<ProductVariation>;
+    createVariation(data: CreateVariationRequest): Observable<ProductVariation>;
+    updateVariation(uniqueId: string, data: UpdateVariationRequest): Observable<ProductVariation>;
+    deleteVariation(uniqueId: string): Observable<void>;
+    listImages(productUniqueId: string): Observable<ProductImage[]>;
+    addImage(productUniqueId: string, imageUrl: string, isPrimary?: boolean): Observable<ProductImage>;
+    deleteImage(uniqueId: string): Observable<void>;
+    getStock(productUniqueId: string, vendorUniqueId?: string): Observable<ProductStock[]>;
+    updateStock(productUniqueId: string, vendorUniqueId: string, warehouseUniqueId: string, quantity: number): Observable<ProductStock>;
+    listReviews(productUniqueId: string): Observable<PageResult<ProductReview>>;
+    addReview(productUniqueId: string, rating: number, title?: string, content?: string): Observable<ProductReview>;
+    getCart(userUniqueId: string): Observable<Cart>;
+    getOrCreateCart(userUniqueId: string): Observable<Cart>;
+    updateCart(userUniqueId: string, data: UpdateCartRequest): Observable<Cart>;
+    deleteCart(userUniqueId: string): Observable<void>;
+    addCartItem(userUniqueId: string, item: AddToCartRequest): Observable<Cart>;
+    updateCartItem(userUniqueId: string, productUniqueId: string, data: UpdateCartItemRequest): Observable<Cart>;
+    removeCartItem(userUniqueId: string, productUniqueId: string): Observable<Cart>;
+    getCartItems(userUniqueId: string): Observable<CartDetail[]>;
+    checkout(userUniqueId: string, data?: CheckoutRequest): Observable<Cart>;
+    orderCart(userUniqueId: string): Observable<{
+        cart: Cart;
+        orderUniqueId: string;
+    }>;
+    orderCartItem(userUniqueId: string, productUniqueId: string): Observable<{
+        cart: Cart;
+        orderUniqueId: string;
+    }>;
+    cancelCart(userUniqueId: string): Observable<Cart>;
+    cancelCartItem(userUniqueId: string, productUniqueId: string): Observable<Cart>;
+    listCategories(params?: ListCategoriesParams): Observable<PageResult<Category>>;
+    getCategory(uniqueId: string): Observable<Category>;
+    createCategory(data: CreateCategoryRequest): Observable<Category>;
+    updateCategory(uniqueId: string, data: UpdateCategoryRequest): Observable<Category>;
+    deleteCategory(uniqueId: string): Observable<void>;
+    recoverCategory(uniqueId: string): Observable<Category>;
+    getCategoryChildren(uniqueId: string): Observable<Category[]>;
+    listBrands(page?: number, perPage?: number): Observable<PageResult<Brand>>;
+    getBrand(uniqueId: string): Observable<Brand>;
+    createBrand(data: CreateBrandRequest): Observable<Brand>;
+    updateBrand(uniqueId: string, data: UpdateBrandRequest): Observable<Brand>;
+    deleteBrand(uniqueId: string): Observable<void>;
+    listVendors(params?: ListVendorsParams): Observable<PageResult<Vendor>>;
+    getVendor(uniqueId: string): Observable<Vendor>;
+    createVendor(data: CreateVendorRequest): Observable<Vendor>;
+    updateVendor(uniqueId: string, data: UpdateVendorRequest): Observable<Vendor>;
+    deleteVendor(uniqueId: string): Observable<void>;
+    listWarehouses(params?: ListWarehousesParams): Observable<PageResult<Warehouse>>;
+    getWarehouse(uniqueId: string): Observable<Warehouse>;
+    createWarehouse(data: CreateWarehouseRequest): Observable<Warehouse>;
+    updateWarehouse(uniqueId: string, data: UpdateWarehouseRequest): Observable<Warehouse>;
+    deleteWarehouse(uniqueId: string): Observable<void>;
+    listChannels(): Observable<Channel[]>;
+    getChannel(uniqueId: string): Observable<Channel>;
+    listCollections(): Observable<Collection[]>;
+    getCollection(uniqueId: string): Observable<Collection>;
+    listProductSets(params?: ListProductSetsParams): Observable<PageResult<ProductSet>>;
+    getProductSet(uniqueId: string): Observable<ProductSet>;
+    createProductSet(data: CreateProductSetRequest): Observable<ProductSet>;
+    updateProductSet(uniqueId: string, data: UpdateProductSetRequest): Observable<ProductSet>;
+    deleteProductSet(uniqueId: string): Observable<void>;
+    listShoppingLists(params?: ListShoppingListsParams): Observable<PageResult<ShoppingList>>;
+    getShoppingList(uniqueId: string): Observable<ShoppingList>;
+    createShoppingList(data: CreateShoppingListRequest): Observable<ShoppingList>;
+    updateShoppingList(uniqueId: string, data: UpdateShoppingListRequest): Observable<ShoppingList>;
+    deleteShoppingList(uniqueId: string): Observable<void>;
+    listProductPromotions(params?: ListProductPromotionsParams): Observable<PageResult<ProductPromotion>>;
+    getProductPromotion(uniqueId: string): Observable<ProductPromotion>;
+    createProductPromotion(data: CreateProductPromotionRequest): Observable<ProductPromotion>;
+    updateProductPromotion(uniqueId: string, data: UpdateProductPromotionRequest): Observable<ProductPromotion>;
+    deleteProductPromotion(uniqueId: string): Observable<void>;
+    listProductPrices(params?: ListProductPricesParams): Observable<PageResult<ProductPrice>>;
+    getProductPrice(uniqueId: string): Observable<ProductPrice>;
+    createProductPrice(data: CreateProductPriceRequest): Observable<ProductPrice>;
+    updateProductPrice(uniqueId: string, data: UpdateProductPriceRequest): Observable<ProductPrice>;
+    deleteProductPrice(uniqueId: string): Observable<void>;
+    listProductFilters(params?: ListProductFiltersParams): Observable<PageResult<ProductFilter>>;
+    getProductFilter(uniqueId: string): Observable<ProductFilter>;
+    createProductFilter(data: CreateProductFilterRequest): Observable<ProductFilter>;
+    updateProductFilter(uniqueId: string, data: UpdateProductFilterRequest): Observable<ProductFilter>;
+    deleteProductFilter(uniqueId: string): Observable<void>;
+    listAddons(productUniqueId: string): Observable<Product[]>;
+    addAddon(productUniqueId: string, addonProductUniqueId: string): Observable<void>;
+    removeAddon(productUniqueId: string, addonUniqueId: string): Observable<void>;
+    getMyCart(uniqueId: string): Observable<Cart>;
+    createMyCart(): Observable<Cart>;
+    updateMyCart(uniqueId: string, data: UpdateMyCartRequest): Observable<Cart>;
+    addToMyCart(data: AddToMyCartRequest): Observable<Cart>;
+    checkoutMyCart(uniqueId: string): Observable<Cart>;
+    orderAllMyCart(uniqueId: string): Observable<Cart>;
+    cancelAllMyCart(uniqueId: string): Observable<Cart>;
+    deleteMyCart(uniqueId: string): Observable<void>;
+    getAbandonedCarts(params?: AbandonedCartsParams): Observable<{
+        carts: AbandonedCart[];
+        total: number;
+    }>;
+    createVisitor(data: CreateVisitorRequest): Observable<Visitor>;
+    /**
+     * List vendors for a product
+     */
+    listProductVendors(productUniqueId: string, params?: ListProductVendorsParams): Observable<PageResult<ProductVendor>>;
+    /**
+     * Get the primary vendor for a product
+     */
+    getPrimaryProductVendor(productUniqueId: string): Observable<ProductVendor | null>;
+    /**
+     * Get available vendors for a product
+     */
+    getAvailableProductVendors(productUniqueId: string, params?: ListProductVendorsParams): Observable<PageResult<ProductVendor>>;
+    /**
+     * Access the underlying block for advanced operations
+     * Use this when you need access to services not wrapped by this Angular service
+     */
+    get productsBlock(): ProductsBlock;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductsService, [{ optional: true; }, { optional: true; }, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProductsService>;
+}
+
+/**
+ * Angular service wrapping the CRM block.
+ * Converts Promise-based APIs to RxJS Observables.
+ *
+ * @example
+ * ```typescript
+ * @Component({...})
+ * export class AccountsComponent {
+ *   constructor(private crm: CrmService) {}
+ *
+ *   loadAccounts() {
+ *     this.crm.listAccounts({ page: 1, perPage: 20 }).subscribe({
+ *       next: (result) => console.log('Accounts:', result.data),
+ *       error: (err) => console.error('Failed:', err),
+ *     });
+ *   }
+ * }
+ * ```
+ */
+declare class CrmService {
+    private readonly block;
+    constructor(serviceTransport: Transport | null, legacyTransport: Transport | null, config: CrmBlockConfig);
+    /**
+     * Ensure the service is configured, throw helpful error if not
+     */
+    private ensureConfigured;
+    listAccounts(params?: ListAccountsParams): Observable<PageResult<Account>>;
+    getAccount(uniqueId: string): Observable<Account>;
+    createAccount(data: CreateAccountRequest): Observable<Account>;
+    updateAccount(uniqueId: string, data: UpdateAccountRequest): Observable<Account>;
+    deleteAccount(uniqueId: string): Observable<void>;
+    recoverAccount(uniqueId: string): Observable<Account>;
+    searchAccounts(query: string, params?: ListAccountsParams): Observable<PageResult<Account>>;
+    listDeletedAccounts(params?: ListAccountsParams): Observable<PageResult<Account>>;
+    listContacts(params?: ListContactsParams): Observable<PageResult<Contact>>;
+    getContact(uniqueId: string): Observable<Contact>;
+    createContact(data: CreateContactRequest): Observable<Contact>;
+    updateContact(uniqueId: string, data: UpdateContactRequest): Observable<Contact>;
+    deleteContact(uniqueId: string): Observable<void>;
+    recoverContact(uniqueId: string): Observable<Contact>;
+    searchContacts(query: string, params?: ListContactsParams): Observable<PageResult<Contact>>;
+    listDeletedContacts(params?: ListContactsParams): Observable<PageResult<Contact>>;
+    listContactEvents(params?: ListContactEventsParams): Observable<PageResult<ContactEvent>>;
+    getContactEvent(uniqueId: string): Observable<ContactEvent>;
+    createContactEvent(data: CreateContactEventRequest): Observable<ContactEvent>;
+    updateContactEvent(uniqueId: string, data: UpdateContactEventRequest): Observable<ContactEvent>;
+    deleteContactEvent(uniqueId: string): Observable<void>;
+    studentConfirmation(uniqueId: string, request?: ConfirmationRequest): Observable<ContactEvent>;
+    studentCheckin(uniqueId: string, request?: CheckinRequest): Observable<ContactEvent>;
+    teacherConfirmation(uniqueId: string, request?: ConfirmationRequest): Observable<ContactEvent>;
+    teacherCheckin(uniqueId: string, request?: CheckinRequest): Observable<ContactEvent>;
+    checkout(uniqueId: string, request?: CheckoutRequest$1): Observable<ContactEvent>;
+    checkoutStudent(uniqueId: string, request?: CheckoutRequest$1): Observable<ContactEvent>;
+    studentNotes(uniqueId: string, request: EventNotesRequest): Observable<ContactEvent>;
+    adminNotes(uniqueId: string, request: EventNotesRequest): Observable<ContactEvent>;
+    listLeads(params?: ListLeadsParams): Observable<PageResult<Lead>>;
+    getLead(uniqueId: string): Observable<Lead>;
+    createLead(data: CreateLeadRequest): Observable<Lead>;
+    updateLead(uniqueId: string, data: UpdateLeadRequest): Observable<Lead>;
+    deleteLead(uniqueId: string): Observable<void>;
+    recoverLead(uniqueId: string): Observable<Lead>;
+    searchLeads(query: string, params?: ListLeadsParams): Observable<PageResult<Lead>>;
+    listDeletedLeads(params?: ListLeadsParams): Observable<PageResult<Lead>>;
+    listLeadFollows(leadUniqueId: string, params?: ListLeadFollowsParams): Observable<PageResult<LeadFollow>>;
+    getLeadFollow(leadUniqueId: string, followUniqueId: string): Observable<LeadFollow>;
+    createLeadFollow(leadUniqueId: string, data: CreateLeadFollowRequest): Observable<LeadFollow>;
+    updateLeadFollow(leadUniqueId: string, followUniqueId: string, data: UpdateLeadFollowRequest): Observable<LeadFollow>;
+    deleteLeadFollow(leadUniqueId: string, followUniqueId: string): Observable<void>;
+    listOpportunities(params?: ListOpportunitiesParams): Observable<PageResult<Opportunity>>;
+    getOpportunity(uniqueId: string): Observable<Opportunity>;
+    createOpportunity(data: CreateOpportunityRequest): Observable<Opportunity>;
+    updateOpportunity(uniqueId: string, data: UpdateOpportunityRequest): Observable<Opportunity>;
+    deleteOpportunity(uniqueId: string): Observable<void>;
+    recoverOpportunity(uniqueId: string): Observable<Opportunity>;
+    searchOpportunities(query: string, params?: ListOpportunitiesParams): Observable<PageResult<Opportunity>>;
+    listDeletedOpportunities(params?: ListOpportunitiesParams): Observable<PageResult<Opportunity>>;
+    listMeetings(params?: ListMeetingsParams): Observable<PageResult<Meeting>>;
+    getMeeting(uniqueId: string): Observable<Meeting>;
+    createMeeting(data: CreateMeetingRequest): Observable<Meeting>;
+    updateMeeting(uniqueId: string, data: UpdateMeetingRequest): Observable<Meeting>;
+    deleteMeeting(uniqueId: string): Observable<void>;
+    recoverMeeting(uniqueId: string): Observable<Meeting>;
+    searchMeetings(query: string, params?: ListMeetingsParams): Observable<PageResult<Meeting>>;
+    listDeletedMeetings(params?: ListMeetingsParams): Observable<PageResult<Meeting>>;
+    listMeetingParticipants(meetingUniqueId: string, params?: ListMeetingParticipantsParams): Observable<PageResult<MeetingParticipant>>;
+    createMeetingParticipant(meetingUniqueId: string, data: CreateMeetingParticipantRequest): Observable<MeetingParticipant>;
+    deleteMeetingParticipant(meetingUniqueId: string, participantUniqueId: string): Observable<void>;
+    listMeetingBillings(meetingUniqueId: string, params?: ListMeetingBillingsParams): Observable<PageResult<MeetingBilling>>;
+    getMeetingBilling(uniqueId: string): Observable<MeetingBilling>;
+    createMeetingBilling(meetingUniqueId: string, data: CreateMeetingBillingRequest): Observable<MeetingBilling>;
+    updateMeetingBilling(uniqueId: string, data: UpdateMeetingBillingRequest): Observable<MeetingBilling>;
+    deleteMeetingBilling(uniqueId: string): Observable<void>;
+    getPaymentSplit(uniqueId: string): Observable<PaymentSplit[]>;
+    getEapSessions(participantEmail: string, payerName: string): Observable<EapSession>;
+    getOutstandingByPayer(): Observable<OutstandingByPayer[]>;
+    getBillingRevenueReport(): Observable<BillingRevenueReport>;
+    getBillingAgingReport(): Observable<BillingAgingReport>;
+    getBillingParticipantReport(participantEmail: string): Observable<BillingParticipantReport>;
+    listQuotes(params?: ListQuotesParams): Observable<PageResult<Quote>>;
+    getQuote(uniqueId: string): Observable<Quote>;
+    createQuote(data: CreateQuoteRequest): Observable<Quote>;
+    updateQuote(uniqueId: string, data: UpdateQuoteRequest): Observable<Quote>;
+    deleteQuote(uniqueId: string): Observable<void>;
+    recoverQuote(uniqueId: string): Observable<Quote>;
+    searchQuotes(query: string, params?: ListQuotesParams): Observable<PageResult<Quote>>;
+    listDeletedQuotes(params?: ListQuotesParams): Observable<PageResult<Quote>>;
+    listSubscribers(params?: ListSubscribersParams): Observable<PageResult<Subscriber>>;
+    getSubscriber(uniqueId: string): Observable<Subscriber>;
+    createSubscriber(data: CreateSubscriberRequest): Observable<Subscriber>;
+    updateSubscriber(uniqueId: string, data: UpdateSubscriberRequest): Observable<Subscriber>;
+    deleteSubscriber(uniqueId: string): Observable<void>;
+    listReferrals(params?: ListReferralsParams): Observable<PageResult<Referral>>;
+    getReferral(uniqueId: string): Observable<Referral>;
+    createReferral(data: CreateReferralRequest): Observable<Referral>;
+    updateReferral(uniqueId: string, data: UpdateReferralRequest): Observable<Referral>;
+    deleteReferral(uniqueId: string): Observable<void>;
+    listTouches(params?: ListTouchesParams): Observable<PageResult<Touch>>;
+    getTouch(uniqueId: string): Observable<Touch>;
+    createTouch(data: CreateTouchRequest): Observable<Touch>;
+    updateTouch(uniqueId: string, data: UpdateTouchRequest): Observable<Touch>;
+    deleteTouch(uniqueId: string): Observable<void>;
+    listCategories(params?: ListCategoriesParams$1): Observable<PageResult<Category$1>>;
+    getCategory(uniqueId: string): Observable<Category$1>;
+    createCategory(data: CreateCategoryRequest$1): Observable<Category$1>;
+    updateCategory(uniqueId: string, data: UpdateCategoryRequest$1): Observable<Category$1>;
+    deleteCategory(uniqueId: string): Observable<void>;
+    listCalendarAccounts(userUniqueId: string, params?: ListCalendarAccountsParams): Observable<PageResult<CalendarAccount>>;
+    getCalendarAccount(userUniqueId: string, id: string): Observable<CalendarAccount>;
+    createCalendarAccount(userUniqueId: string, data: CreateCalendarAccountRequest): Observable<CalendarAccount>;
+    updateCalendarAccount(userUniqueId: string, id: string, data: UpdateCalendarAccountRequest): Observable<CalendarAccount>;
+    deleteCalendarAccount(userUniqueId: string, id: string): Observable<void>;
+    syncUserCalendar(userUniqueId: string, request?: SyncCalendarRequest): Observable<SyncCalendarResponse>;
+    syncTenantCalendar(request?: SyncCalendarRequest): Observable<SyncCalendarResponse>;
+    listBusyBlocks(userUniqueId: string, params?: ListBusyBlocksParams): Observable<PageResult<BusyBlock>>;
+    createBusyBlock(userUniqueId: string, data: CreateBusyBlockRequest): Observable<BusyBlock>;
+    deleteBusyBlock(userUniqueId: string, id: string): Observable<void>;
+    listIcsTokens(userUniqueId: string, params?: ListIcsTokensParams): Observable<PageResult<IcsToken>>;
+    createIcsToken(userUniqueId: string, data: CreateIcsTokenRequest): Observable<IcsToken>;
+    deleteIcsToken(userUniqueId: string, id: string): Observable<void>;
+    getZoomMeeting(userUniqueId: string, meetingUniqueId: string): Observable<ZoomMeeting>;
+    provisionZoomMeeting(userUniqueId: string, meetingUniqueId: string, request?: ProvisionZoomMeetingRequest): Observable<ZoomMeeting>;
+    updateZoomMeeting(userUniqueId: string, meetingUniqueId: string, request: UpdateZoomMeetingRequest): Observable<ZoomMeeting>;
+    cancelZoomMeeting(userUniqueId: string, meetingUniqueId: string): Observable<void>;
+    checkZoomAvailability(userUniqueId: string): Observable<ZoomAvailability>;
+    listZoomHosts(params?: ListZoomHostsParams): Observable<PageResult<ZoomHost>>;
+    getZoomHost(uniqueId: string): Observable<ZoomHost>;
+    createZoomHost(data: CreateZoomHostRequest): Observable<ZoomHost>;
+    updateZoomHost(uniqueId: string, data: UpdateZoomHostRequest): Observable<ZoomHost>;
+    deleteZoomHost(uniqueId: string): Observable<void>;
+    getZoomHostAvailability(uniqueId: string): Observable<ZoomHostAvailability>;
+    getZoomHostAllocations(uniqueId: string): Observable<ZoomHostAllocation[]>;
+    getAvailableZoomUsers(): Observable<AvailableUser[]>;
+    listMailTemplates(params?: ListCrmMailTemplatesParams): Observable<PageResult<CrmMailTemplate>>;
+    getMailTemplate(uniqueId: string): Observable<CrmMailTemplate>;
+    createMailTemplate(data: CreateCrmMailTemplateRequest): Observable<CrmMailTemplate>;
+    updateMailTemplate(uniqueId: string, data: UpdateCrmMailTemplateRequest): Observable<CrmMailTemplate>;
+    getMandrillStats(uniqueId: string): Observable<MandrillTemplateStats>;
+    createMandrillTemplate(uniqueId: string, data: CreateMandrillTemplateRequest): Observable<CrmMailTemplate>;
+    updateMandrillTemplate(uniqueId: string, data: UpdateMandrillTemplateRequest): Observable<CrmMailTemplate>;
+    publishMandrill(uniqueId: string): Observable<CrmMailTemplate>;
+    unsubscribe(data: UnsubscribeRequest): Observable<UnsubscribeResponse>;
+    listCrmUsers(params?: ListCrmUsersParams): Observable<PageResult<CrmUser>>;
+    getCrmUser(uniqueId: string): Observable<CrmUser>;
+    registerCrmUser(uniqueId: string, data: RegisterCrmUserRequest): Observable<CrmUser>;
+    deleteCrmUser(uniqueId: string): Observable<void>;
+    getCrmUserContacts(uniqueId: string): Observable<Contact[]>;
+    getCrmUserMeetings(uniqueId: string): Observable<Meeting[]>;
+    getRevenueReport(params?: BillingReportParams): Observable<RevenueReport>;
+    getAgingReport(): Observable<AgingReport>;
+    getParticipantBillingReport(participantEmail: string): Observable<ParticipantBillingReport>;
+    syncCalendarUser(userUniqueId: string): Observable<CalendarSyncResult>;
+    syncCalendarTenant(): Observable<CalendarSyncResult>;
+    /**
+     * Access the underlying block for advanced operations
+     * Use this when you need access to services not wrapped by this Angular service
+     */
+    get crmBlock(): CrmBlock;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CrmService, [{ optional: true; }, { optional: true; }, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CrmService>;
+}
+
+/**
+ * Angular service wrapping the Content block.
+ * Converts Promise-based APIs to RxJS Observables.
+ *
+ * @example
+ * ```typescript
+ * @Component({...})
+ * export class BlogComponent {
+ *   constructor(private content: ContentService) {}
+ *
+ *   loadPosts() {
+ *     this.content.listPosts({ page: 1, perPage: 10 }).subscribe({
+ *       next: (result) => console.log('Posts:', result.data),
+ *       error: (err) => console.error('Failed:', err),
+ *     });
+ *   }
+ * }
+ * ```
+ */
+declare class ContentService {
+    private readonly block;
+    constructor(serviceTransport: Transport | null, legacyTransport: Transport | null, config: ContentBlockConfig);
+    /**
+     * Ensure the service is configured, throw helpful error if not
+     */
+    private ensureConfigured;
+    listPosts(params?: ListPostsParams): Observable<PageResult<Post>>;
+    getPost(uniqueId: string): Observable<Post>;
+    createPost(data: CreatePostRequest): Observable<Post>;
+    updatePost(uniqueId: string, data: UpdatePostRequest): Observable<Post>;
+    deletePost(uniqueId: string): Observable<void>;
+    recoverPost(uniqueId: string): Observable<Post>;
+    searchPosts(query: string, params?: ListPostsParams): Observable<PageResult<Post>>;
+    listDeletedPosts(params?: ListPostsParams): Observable<PageResult<Post>>;
+    likePost(uniqueId: string): Observable<Post>;
+    dislikePost(uniqueId: string): Observable<Post>;
+    savePost(uniqueId: string): Observable<Post>;
+    followPost(uniqueId: string): Observable<Post>;
+    listComments(params?: ListCommentsParams): Observable<PageResult<Comment>>;
+    getComment(uniqueId: string): Observable<Comment>;
+    createComment(data: CreateCommentRequest): Observable<Comment>;
+    updateComment(uniqueId: string, data: UpdateCommentRequest): Observable<Comment>;
+    deleteComment(uniqueId: string): Observable<void>;
+    likeComment(uniqueId: string): Observable<Comment>;
+    dislikeComment(uniqueId: string): Observable<Comment>;
+    listCategories(params?: ListCategoriesParams$2): Observable<PageResult<Category$2>>;
+    getCategory(uniqueId: string): Observable<Category$2>;
+    createCategory(data: CreateCategoryRequest$2): Observable<Category$2>;
+    updateCategory(uniqueId: string, data: UpdateCategoryRequest$2): Observable<Category$2>;
+    deleteCategory(uniqueId: string): Observable<void>;
+    recoverCategory(uniqueId: string): Observable<Category$2>;
+    getCategoryChildren(uniqueId: string): Observable<Category$2[]>;
+    listTags(params?: ListTagsParams): Observable<PageResult<Tag>>;
+    getTag(uniqueId: string): Observable<Tag>;
+    createTag(data: CreateTagRequest): Observable<Tag>;
+    updateTag(uniqueId: string, data: UpdateTagRequest): Observable<Tag>;
+    deleteTag(uniqueId: string): Observable<void>;
+    listContentUsers(params?: ListContentUsersParams): Observable<PageResult<ContentUser>>;
+    getContentUser(uniqueId: string): Observable<ContentUser>;
+    registerContentUser(uniqueId: string, data: RegisterContentUserRequest): Observable<ContentUser>;
+    updateContentUser(uniqueId: string, data: UpdateContentUserRequest): Observable<ContentUser>;
+    getUserDrafts(uniqueId: string): Observable<Post[]>;
+    getUserPosts(uniqueId: string): Observable<Post[]>;
+    getUserComments(uniqueId: string): Observable<Comment[]>;
+    getUserActivities(uniqueId: string): Observable<UserActivity[]>;
+    addUserTag(uniqueId: string, tagUniqueId: string): Observable<ContentUser>;
+    removeUserTag(uniqueId: string, tagUniqueId: string): Observable<void>;
+    getUserFollowers(uniqueId: string): Observable<ContentUser[]>;
+    getUserFollowing(uniqueId: string): Observable<ContentUser[]>;
+    followContentUser(uniqueId: string, targetUserUniqueId: string): Observable<void>;
+    unfollowContentUser(uniqueId: string, targetUserUniqueId: string): Observable<void>;
+    /**
+     * Moderate a post
+     */
+    moderatePost(uniqueId: string, request: ModerateContentRequest): Observable<ModerationResult>;
+    /**
+     * Moderate a comment
+     */
+    moderateComment(uniqueId: string, request: ModerateContentRequest): Observable<ModerationResult>;
+    /**
+     * List content flags
+     */
+    listContentFlags(params?: ListContentFlagsParams): Observable<PageResult<ContentFlag>>;
+    /**
+     * Create a content flag
+     */
+    createContentFlag(request: CreateContentFlagRequest): Observable<ContentFlag>;
+    /**
+     * Resolve a content flag
+     */
+    resolveContentFlag(uniqueId: string, resolution: string): Observable<ContentFlag>;
+    /**
+     * Get activities
+     */
+    listActivities(params?: ListActivitiesParams): Observable<PageResult<Activity>>;
+    /**
+     * Get comments activities for a post
+     */
+    getCommentsActivities(postUniqueId: string): Observable<Activity[]>;
+    /**
+     * Get activity feed for a user
+     */
+    getActivityFeed(userUniqueId: string, params?: ListActivitiesParams): Observable<PageResult<Activity>>;
+    /**
+     * List all series with pagination
+     */
+    listSeries(params?: ListSeriesParams): Observable<PageResult<Series>>;
+    /**
+     * Query series with filters
+     */
+    querySeries(params: QuerySeriesParams): Observable<PageResult<Series>>;
+    /**
+     * Get a series by unique ID
+     */
+    getSeries(uniqueId: string): Observable<Series>;
+    /**
+     * Create a new series
+     */
+    createSeries(data: CreateSeriesRequest): Observable<Series>;
+    /**
+     * Update a series
+     */
+    updateSeries(uniqueId: string, data: UpdateSeriesRequest): Observable<Series>;
+    /**
+     * Delete a series
+     */
+    deleteSeries(uniqueId: string): Observable<void>;
+    /**
+     * Like a series
+     */
+    likeSeries(uniqueId: string): Observable<Series>;
+    /**
+     * Dislike a series
+     */
+    dislikeSeries(uniqueId: string): Observable<Series>;
+    /**
+     * Follow a series
+     */
+    followSeries(uniqueId: string): Observable<Series>;
+    /**
+     * Unfollow a series
+     */
+    unfollowSeries(uniqueId: string): Observable<void>;
+    /**
+     * Save a series
+     */
+    saveSeries(uniqueId: string): Observable<Series>;
+    /**
+     * Unsave a series
+     */
+    unsaveSeries(uniqueId: string): Observable<void>;
+    /**
+     * Get posts in a series
+     */
+    getSeriesPosts(uniqueId: string): Observable<Post[]>;
+    /**
+     * Add a post to a series
+     */
+    addSeriesPost(seriesUniqueId: string, postUniqueId: string, sequence?: number): Observable<void>;
+    /**
+     * Remove a post from a series
+     */
+    removeSeriesPost(seriesUniqueId: string, postUniqueId: string): Observable<void>;
+    /**
+     * Reorder posts in a series
+     */
+    reorderSeriesPosts(uniqueId: string, data: ReorderPostsRequest): Observable<Series>;
+    /**
+     * Access the underlying block for advanced operations
+     * Use this when you need access to services not wrapped by this Angular service
+     */
+    get contentBlock(): ContentBlock;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContentService, [{ optional: true; }, { optional: true; }, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ContentService>;
+}
+
+/**
+ * Angular service wrapping the Geolocation block.
+ * Converts Promise-based APIs to RxJS Observables.
+ *
+ * @example
+ * ```typescript
+ * @Component({...})
+ * export class MapComponent {
+ *   constructor(private geolocation: GeolocationService) {}
+ *
+ *   loadLocations() {
+ *     this.geolocation.listLocations().subscribe({
+ *       next: (result) => console.log('Locations:', result.data),
+ *       error: (err) => console.error('Failed:', err),
+ *     });
+ *   }
+ * }
+ * ```
+ */
+declare class GeolocationService {
+    private readonly block;
+    constructor(serviceTransport: Transport | null, legacyTransport: Transport | null, config: GeolocationBlockConfig);
+    /**
+     * Ensure the service is configured, throw helpful error if not
+     */
+    private ensureConfigured;
+    listLocations(params?: ListLocationsParams): Observable<PageResult<Location>>;
+    getLocation(uniqueId: string): Observable<Location>;
+    createLocation(data: CreateLocationRequest): Observable<Location>;
+    updateLocation(uniqueId: string, data: UpdateLocationRequest): Observable<Location>;
+    deleteLocation(uniqueId: string): Observable<void>;
+    recoverLocation(uniqueId: string): Observable<Location>;
+    searchLocations(query: string, params?: ListLocationsParams): Observable<PageResult<Location>>;
+    listDeletedLocations(params?: ListLocationsParams): Observable<PageResult<Location>>;
+    listAddresses(params?: ListAddressesParams): Observable<PageResult<Address>>;
+    getAddress(uniqueId: string): Observable<Address>;
+    createAddress(data: CreateAddressRequest): Observable<Address>;
+    updateAddress(uniqueId: string, data: UpdateAddressRequest): Observable<Address>;
+    deleteAddress(uniqueId: string): Observable<void>;
+    recoverAddress(uniqueId: string): Observable<Address>;
+    searchAddresses(query: string, params?: ListAddressesParams): Observable<PageResult<Address>>;
+    listDeletedAddresses(params?: ListAddressesParams): Observable<PageResult<Address>>;
+    setDefaultAddress(uniqueId: string): Observable<Address>;
+    listAreas(params?: ListAreasParams): Observable<PageResult<Area>>;
+    getArea(uniqueId: string): Observable<Area>;
+    createArea(data: CreateAreaRequest): Observable<Area>;
+    updateArea(uniqueId: string, data: UpdateAreaRequest): Observable<Area>;
+    deleteArea(uniqueId: string): Observable<void>;
+    recoverArea(uniqueId: string): Observable<Area>;
+    searchAreas(query: string, params?: ListAreasParams): Observable<PageResult<Area>>;
+    listDeletedAreas(params?: ListAreasParams): Observable<PageResult<Area>>;
+    listRegions(params?: ListRegionsParams): Observable<PageResult<Region>>;
+    getRegion(uniqueId: string): Observable<Region>;
+    createRegion(data: CreateRegionRequest): Observable<Region>;
+    updateRegion(uniqueId: string, data: UpdateRegionRequest): Observable<Region>;
+    deleteRegion(uniqueId: string): Observable<void>;
+    recoverRegion(uniqueId: string): Observable<Region>;
+    searchRegions(query: string, params?: ListRegionsParams): Observable<PageResult<Region>>;
+    listDeletedRegions(params?: ListRegionsParams): Observable<PageResult<Region>>;
+    listRoutes(params?: ListTravelRoutesParams): Observable<PageResult<TravelRoute>>;
+    getRoute(uniqueId: string): Observable<TravelRoute>;
+    createRoute(data: CreateTravelRouteRequest): Observable<TravelRoute>;
+    updateRoute(uniqueId: string, data: UpdateTravelRouteRequest): Observable<TravelRoute>;
+    deleteRoute(uniqueId: string): Observable<void>;
+    recoverRoute(uniqueId: string): Observable<TravelRoute>;
+    searchRoutes(query: string, params?: ListTravelRoutesParams): Observable<PageResult<TravelRoute>>;
+    listDeletedRoutes(params?: ListTravelRoutesParams): Observable<PageResult<TravelRoute>>;
+    listBookings(params?: ListPremiseBookingsParams): Observable<PageResult<PremiseBooking>>;
+    getBooking(uniqueId: string): Observable<PremiseBooking>;
+    createBooking(data: CreatePremiseBookingRequest): Observable<PremiseBooking>;
+    updateBooking(uniqueId: string, data: UpdatePremiseBookingRequest): Observable<PremiseBooking>;
+    deleteBooking(uniqueId: string): Observable<void>;
+    recoverBooking(uniqueId: string): Observable<PremiseBooking>;
+    searchBookings(query: string, params?: ListPremiseBookingsParams): Observable<PageResult<PremiseBooking>>;
+    listDeletedBookings(params?: ListPremiseBookingsParams): Observable<PageResult<PremiseBooking>>;
+    listPremises(params?: ListPremisesParams): Observable<PageResult<Premise>>;
+    getPremise(uniqueId: string): Observable<Premise>;
+    createPremise(data: CreatePremiseRequest): Observable<Premise>;
+    updatePremise(uniqueId: string, data: UpdatePremiseRequest): Observable<Premise>;
+    deletePremise(uniqueId: string): Observable<void>;
+    recoverPremise(uniqueId: string): Observable<Premise>;
+    searchPremises(query: string, params?: ListPremisesParams): Observable<PageResult<Premise>>;
+    listDeletedPremises(params?: ListPremisesParams): Observable<PageResult<Premise>>;
+    /**
+     * List all premise events
+     */
+    listPremiseEvents(locationUniqueId: string, premiseUniqueId: string, params?: ListPremiseEventsParams): Observable<PageResult<PremiseEvent>>;
+    /**
+     * Get a premise event by unique ID
+     */
+    getPremiseEvent(locationUniqueId: string, premiseUniqueId: string, uniqueId: string): Observable<PremiseEvent>;
+    /**
+     * Create a new premise event
+     */
+    createPremiseEvent(locationUniqueId: string, premiseUniqueId: string, data: CreatePremiseEventRequest): Observable<PremiseEvent>;
+    /**
+     * Update a premise event
+     */
+    updatePremiseEvent(locationUniqueId: string, premiseUniqueId: string, uniqueId: string, data: UpdatePremiseEventRequest): Observable<PremiseEvent>;
+    /**
+     * Delete a premise event
+     */
+    deletePremiseEvent(locationUniqueId: string, premiseUniqueId: string, uniqueId: string): Observable<void>;
+    /**
+     * Record a location point for a route
+     */
+    recordRouteLocation(userUniqueId: string, routeUniqueId: string, data: CreateRouteLocationRequest): Observable<RouteLocation>;
+    /**
+     * Get route tracking status
+     */
+    getRouteTrackerStatus(userUniqueId: string, routeUniqueId: string): Observable<RouteTrackerStatus>;
+    /**
+     * List all recorded locations for a route
+     */
+    listRouteLocations(userUniqueId: string, routeUniqueId: string, params?: ListRouteLocationsParams): Observable<PageResult<RouteLocation>>;
+    /**
+     * Start tracking for a route
+     */
+    startRouteTracking(userUniqueId: string, routeUniqueId: string): Observable<RouteTrackerStatus>;
+    /**
+     * Stop tracking for a route
+     */
+    stopRouteTracking(userUniqueId: string, routeUniqueId: string): Observable<RouteTrackerStatus>;
+    /**
+     * List all hours for a location
+     */
+    listLocationHours(locationUniqueId: string): Observable<LocationHour[]>;
+    /**
+     * Get a location hour by unique ID
+     */
+    getLocationHour(locationUniqueId: string, hourUniqueId: string): Observable<LocationHour>;
+    /**
+     * Create a new location hour
+     */
+    createLocationHour(locationUniqueId: string, data: CreateLocationHourRequest): Observable<LocationHour>;
+    /**
+     * Update a location hour
+     */
+    updateLocationHour(locationUniqueId: string, hourUniqueId: string, data: UpdateLocationHourRequest): Observable<LocationHour>;
+    /**
+     * Delete a location hour
+     */
+    deleteLocationHour(locationUniqueId: string, hourUniqueId: string): Observable<void>;
+    /**
+     * Get a presigned URL for uploading an image
+     */
+    presignLocationImage(locationUniqueId: string, data: PresignLocationImageRequest): Observable<PresignLocationImageResponse>;
+    /**
+     * Create a new location image
+     */
+    createLocationImage(locationUniqueId: string, data: CreateLocationImageRequest): Observable<LocationImage>;
+    /**
+     * Delete a location image
+     */
+    deleteLocationImage(locationUniqueId: string, imageUniqueId: string): Observable<void>;
+    /**
+     * List all slots for a location
+     */
+    listLocationSlots(locationUniqueId: string): Observable<LocationSlot[]>;
+    /**
+     * Get a location slot by unique ID
+     */
+    getLocationSlot(locationUniqueId: string, slotUniqueId: string): Observable<LocationSlot>;
+    /**
+     * Create a new location slot
+     */
+    createLocationSlot(locationUniqueId: string, data: CreateLocationSlotRequest): Observable<LocationSlot>;
+    /**
+     * Update a location slot
+     */
+    updateLocationSlot(locationUniqueId: string, slotUniqueId: string, data: UpdateLocationSlotRequest): Observable<LocationSlot>;
+    /**
+     * Delete a location slot
+     */
+    deleteLocationSlot(locationUniqueId: string, slotUniqueId: string): Observable<void>;
+    /**
+     * Create a new location tax
+     */
+    createLocationTax(locationUniqueId: string, data: CreateLocationTaxRequest): Observable<LocationTax>;
+    /**
+     * Update a location tax
+     */
+    updateLocationTax(locationUniqueId: string, taxUniqueId: string, data: UpdateLocationTaxRequest): Observable<LocationTax>;
+    /**
+     * Delete a location tax
+     */
+    deleteLocationTax(locationUniqueId: string, taxUniqueId: string): Observable<void>;
+    /**
+     * List all location groups
+     */
+    listLocationGroups(params?: ListLocationGroupsParams): Observable<PageResult<LocationGroup>>;
+    /**
+     * Get a location group by unique ID
+     */
+    getLocationGroup(uniqueId: string): Observable<LocationGroup>;
+    /**
+     * Create a new location group
+     */
+    createLocationGroup(data: CreateLocationGroupRequest): Observable<LocationGroup>;
+    /**
+     * List all geo identities
+     */
+    listGeoIdentities(params?: ListGeoIdentitiesParams): Observable<PageResult<GeoIdentity>>;
+    /**
+     * Get a geo identity by unique ID
+     */
+    getGeoIdentity(uniqueId: string): Observable<GeoIdentity>;
+    /**
+     * Register a geo identity
+     */
+    registerGeoIdentity(uniqueId: string, data: RegisterGeoIdentityRequest): Observable<GeoIdentity>;
+    /**
+     * Update a geo identity
+     */
+    updateGeoIdentity(uniqueId: string, data: UpdateGeoIdentityRequest): Observable<GeoIdentity>;
+    /**
+     * Delete a geo identity
+     */
+    deleteGeoIdentity(uniqueId: string): Observable<void>;
+    /**
+     * Add an identity to a location
+     */
+    addIdentityToLocation(locationUniqueId: string, data: LocationIdentityRequest): Observable<void>;
+    /**
+     * Remove an identity from a location
+     */
+    removeIdentityFromLocation(locationUniqueId: string, userUniqueId: string): Observable<void>;
+    /**
+     * Update a user's location
+     */
+    updateUserLocation(userUniqueId: string, data: UserLocationRequest): Observable<void>;
+    /**
+     * List all location identities
+     */
+    listLocationIdentities(params?: ListLocationIdentitiesParams): Observable<PageResult<LocationIdentity>>;
+    /**
+     * Get a location identity by unique ID
+     */
+    getLocationIdentity(uniqueId: string): Observable<LocationIdentity>;
+    /**
+     * Create a new location identity
+     */
+    createLocationIdentity(data: CreateLocationIdentityRequest): Observable<LocationIdentity>;
+    /**
+     * Update a location identity
+     */
+    updateLocationIdentity(uniqueId: string, data: UpdateLocationIdentityRequest): Observable<LocationIdentity>;
+    /**
+     * Delete a location identity
+     */
+    deleteLocationIdentity(uniqueId: string): Observable<void>;
+    /**
+     * Check in an identity at a location
+     */
+    checkInLocationIdentity(locationUniqueId: string, identityUniqueId: string, identityType: string): Observable<LocationIdentity>;
+    /**
+     * Check out an identity from a location
+     */
+    checkOutLocationIdentity(uniqueId: string): Observable<LocationIdentity>;
+    /**
+     * List identities by location
+     */
+    listLocationIdentitiesByLocation(locationUniqueId: string, params?: ListLocationIdentitiesParams): Observable<PageResult<LocationIdentity>>;
+    /**
+     * List identities by identity
+     */
+    listLocationIdentitiesByIdentity(identityUniqueId: string, identityType: string, params?: ListLocationIdentitiesParams): Observable<PageResult<LocationIdentity>>;
+    /**
+     * Get current location for an identity
+     */
+    getCurrentLocationForIdentity(identityUniqueId: string, identityType: string): Observable<LocationIdentity | null>;
+    /**
+     * List all countries
+     */
+    listGeoCountries(params?: GeoLookupParams): Observable<PageResult<GeoCountry>>;
+    /**
+     * Get a country by code
+     */
+    getGeoCountry(code: string): Observable<GeoCountry>;
+    /**
+     * Search countries by name
+     */
+    searchGeoCountries(query: string, params?: GeoLookupParams): Observable<PageResult<GeoCountry>>;
+    /**
+     * List states by country
+     */
+    listGeoStates(countryCode: string, params?: GeoLookupParams): Observable<PageResult<GeoState>>;
+    /**
+     * Get a state by code
+     */
+    getGeoState(code: string): Observable<GeoState>;
+    /**
+     * Search states by name
+     */
+    searchGeoStates(query: string, countryCode?: string, params?: GeoLookupParams): Observable<PageResult<GeoState>>;
+    /**
+     * List cities by state or country
+     */
+    listGeoCities(countryCode: string, stateCode?: string, params?: GeoLookupParams): Observable<PageResult<GeoCity>>;
+    /**
+     * Get a city by code
+     */
+    getGeoCity(code: string): Observable<GeoCity>;
+    /**
+     * Search cities by name
+     */
+    searchGeoCities(query: string, countryCode?: string, stateCode?: string, params?: GeoLookupParams): Observable<PageResult<GeoCity>>;
+    /**
+     * Access the underlying block for advanced operations
+     * Use this when you need access to services not wrapped by this Angular service
+     */
+    get geolocationBlock(): GeolocationBlock;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GeolocationService, [{ optional: true; }, { optional: true; }, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GeolocationService>;
+}
+
+/**
+ * Angular service wrapping the Conversations block.
+ * Converts Promise-based APIs to RxJS Observables.
+ *
+ * @example
+ * ```typescript
+ * @Component({...})
+ * export class ChatComponent {
+ *   constructor(private conversations: ConversationsService) {}
+ *
+ *   sendMessage(contextId: string, content: string) {
+ *     this.conversations.createMessage({ contextId, content }).subscribe({
+ *       next: (message) => console.log('Message sent:', message),
+ *       error: (err) => console.error('Failed:', err),
+ *     });
+ *   }
+ * }
+ * ```
+ */
+declare class ConversationsService {
+    private readonly block;
+    constructor(serviceTransport: Transport | null, legacyTransport: Transport | null, config: ConversationsBlockConfig);
+    /**
+     * Ensure the service is configured, throw helpful error if not
+     */
+    private ensureConfigured;
+    listMessages(params?: ListMessagesParams): Observable<PageResult<Message>>;
+    getMessage(uniqueId: string): Observable<Message>;
+    createMessage(data: CreateMessageRequest): Observable<Message>;
+    updateMessage(uniqueId: string, data: UpdateMessageRequest): Observable<Message>;
+    deleteMessage(uniqueId: string): Observable<void>;
+    recoverMessage(uniqueId: string): Observable<Message>;
+    listMessagesByContext(contextId: string, params?: ListMessagesParams): Observable<PageResult<Message>>;
+    listMessagesByParent(parentId: string, params?: ListMessagesParams): Observable<PageResult<Message>>;
+    listDeletedMessages(params?: ListMessagesParams): Observable<PageResult<Message>>;
+    listDraftMessages(params?: ListDraftMessagesParams): Observable<PageResult<DraftMessage>>;
+    getDraftMessage(uniqueId: string): Observable<DraftMessage>;
+    createDraftMessage(data: CreateDraftMessageRequest): Observable<DraftMessage>;
+    updateDraftMessage(uniqueId: string, data: UpdateDraftMessageRequest): Observable<DraftMessage>;
+    deleteDraftMessage(uniqueId: string): Observable<void>;
+    listDraftMessagesByContext(contextId: string, params?: ListDraftMessagesParams): Observable<PageResult<DraftMessage>>;
+    publishDraftMessage(uniqueId: string): Observable<DraftMessage>;
+    listGroups(params?: ListGroupsParams): Observable<PageResult<Group>>;
+    getGroup(uniqueId: string): Observable<Group>;
+    createGroup(data: CreateGroupRequest): Observable<Group>;
+    updateGroup(uniqueId: string, data: UpdateGroupRequest): Observable<Group>;
+    deleteGroup(uniqueId: string): Observable<void>;
+    recoverGroup(uniqueId: string): Observable<Group>;
+    searchGroups(query: string, params?: ListGroupsParams): Observable<PageResult<Group>>;
+    listDeletedGroups(params?: ListGroupsParams): Observable<PageResult<Group>>;
+    addGroupMember(uniqueId: string, memberId: string): Observable<Group>;
+    removeGroupMember(uniqueId: string, memberId: string): Observable<Group>;
+    listGroupInvites(groupUniqueId: string, params?: ListGroupInvitesParams): Observable<PageResult<GroupInvite>>;
+    createGroupInvite(groupUniqueId: string, data?: CreateGroupInviteRequest): Observable<GroupInvite>;
+    revokeGroupInvite(groupUniqueId: string, code: string): Observable<void>;
+    getGroupInviteQRCode(groupUniqueId: string, code: string): Observable<QRCodeResponse>;
+    joinGroupByInvite(code: string, data?: JoinGroupRequest): Observable<Group>;
+    listNotifications(params?: ListNotificationsParams): Observable<PageResult<Notification>>;
+    getNotification(uniqueId: string): Observable<Notification>;
+    createNotification(data: CreateNotificationRequest): Observable<Notification>;
+    updateNotification(uniqueId: string, data: UpdateNotificationRequest): Observable<Notification>;
+    deleteNotification(uniqueId: string): Observable<void>;
+    markNotificationAsRead(uniqueId: string): Observable<Notification>;
+    markNotificationAsUnread(uniqueId: string): Observable<Notification>;
+    listNotificationsByTarget(targetId: string, params?: ListNotificationsParams): Observable<PageResult<Notification>>;
+    listUnreadNotifications(params?: ListNotificationsParams): Observable<PageResult<Notification>>;
+    getConversation(params: GetConversationParams): Observable<Conversation>;
+    listConversationContexts(): Observable<string[]>;
+    deleteConversationContext(context: string): Observable<void>;
+    createWebSocketToken(data?: CreateWebSocketTokenRequest): Observable<CreateWebSocketTokenResponse>;
+    listContexts(params?: ListContextsParams): Observable<PageResult<Context>>;
+    getContext(uniqueId: string): Observable<Context>;
+    createContext(data: CreateContextRequest): Observable<Context>;
+    updateContext(uniqueId: string, data: UpdateContextRequest): Observable<Context>;
+    listContextGroups(contextUniqueId: string): Observable<PageResult<Group>>;
+    getNotificationSettings(userUniqueId: string): Observable<NotificationSettings>;
+    updateNotificationSettings(userUniqueId: string, data: UpdateNotificationSettingsRequest): Observable<NotificationSettings>;
+    getUserAvailability(userUniqueId: string): Observable<UserAvailability>;
+    goOnline(data?: SetAvailabilityRequest): Observable<UserAvailability>;
+    goOffline(): Observable<void>;
+    getMessageFile(conversationUniqueId: string, fileUniqueId: string): Observable<MessageFile>;
+    createMessageFile(conversationUniqueId: string, data: CreateMessageFileRequest): Observable<MessageFile>;
+    deleteMessageFile(conversationUniqueId: string, fileUniqueId: string): Observable<void>;
+    presignMessageFile(conversationUniqueId: string, data: PresignMessageFileRequest): Observable<PresignMessageFileResponse>;
+    getSource(uniqueId: string): Observable<Source>;
+    listConversationsUsers(params?: ListUsersParams): Observable<PageResult<ConversationsUser>>;
+    getConversationsUser(uniqueId: string): Observable<ConversationsUser>;
+    registerConversationsUser(uniqueId: string, data?: RegisterUserRequest): Observable<ConversationsUser>;
+    updateConversationsUser(uniqueId: string, data: UpdateUserRequest$1): Observable<ConversationsUser>;
+    listUserGroups(uniqueId: string): Observable<PageResult<Group>>;
+    listUserConversations(uniqueId: string, params?: {
+        page?: number;
+        perPage?: number;
+    }): Observable<PageResult<Conversation>>;
+    listUserGroupConversations(uniqueId: string, params?: {
+        page?: number;
+        perPage?: number;
+    }): Observable<PageResult<Conversation>>;
+    listUserContextGroups(uniqueId: string, contextUniqueId: string): Observable<PageResult<Group>>;
+    listMeetings(params?: ListMeetingsParams$1): Observable<PageResult<Meeting$1>>;
+    getMeeting(uniqueId: string): Observable<Meeting$1>;
+    createMeeting(data: CreateMeetingRequest$1): Observable<Meeting$1>;
+    updateMeeting(uniqueId: string, data: UpdateMeetingRequest$1): Observable<Meeting$1>;
+    deleteMeeting(uniqueId: string): Observable<void>;
+    createMeetingSession(uniqueId: string): Observable<MeetingSession>;
+    startMeeting(uniqueId: string): Observable<Meeting$1>;
+    endMeeting(uniqueId: string): Observable<Meeting$1>;
+    listWebNotifications(params?: ListWebNotificationsParams): Observable<PageResult<WebNotification>>;
+    getWebNotification(uniqueId: string): Observable<WebNotification>;
+    sendWebNotification(data: CreateWebNotificationRequest): Observable<WebNotification>;
+    sendBulkWebNotifications(data: BulkWebNotificationRequest): Observable<{
+        sent: number;
+        failed: number;
+    }>;
+    markWebNotificationAsRead(uniqueId: string): Observable<WebNotification>;
+    markWebNotificationAsClicked(uniqueId: string): Observable<WebNotification>;
+    markAllWebNotificationsAsRead(recipientUniqueId: string): Observable<{
+        updated: number;
+    }>;
+    deleteWebNotification(uniqueId: string): Observable<void>;
+    /**
+     * Access the underlying block for advanced operations
+     * Use this when you need access to services not wrapped by this Angular service
+     */
+    get conversationsBlock(): ConversationsBlock;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConversationsService, [{ optional: true; }, { optional: true; }, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConversationsService>;
+}
+
+/**
+ * Angular service wrapping the Files block.
+ * Converts Promise-based APIs to RxJS Observables.
+ *
+ * @example
+ * ```typescript
+ * @Component({...})
+ * export class FileUploadComponent {
+ *   constructor(private files: FilesService) {}
+ *
+ *   uploadFile(file: File) {
+ *     this.files.uploadStorageFile({
+ *       file,
+ *       fileName: file.name,
+ *       ownerUniqueId: 'user-123',
+ *       ownerType: 'User',
+ *     }).subscribe({
+ *       next: (storageFile) => console.log('Uploaded:', storageFile),
+ *       error: (err) => console.error('Failed:', err),
+ *     });
+ *   }
+ * }
+ * ```
+ */
+declare class FilesService {
+    private readonly block;
+    constructor(serviceTransport: Transport | null, legacyTransport: Transport | null, config: FilesBlockConfig);
+    /**
+     * Ensure the service is configured, throw helpful error if not
+     */
+    private ensureConfigured;
+    listStorageFiles(params?: ListStorageFilesParams): Observable<PageResult<StorageFile>>;
+    getStorageFile(uniqueId: string): Observable<StorageFile>;
+    uploadStorageFile(data: UploadFileRequest): Observable<StorageFile>;
+    createStorageFile(data: CreateStorageFileRequest): Observable<StorageFile>;
+    updateStorageFile(uniqueId: string, data: UpdateStorageFileRequest): Observable<StorageFile>;
+    deleteStorageFile(uniqueId: string): Observable<void>;
+    downloadStorageFile(uniqueId: string): Observable<Blob>;
+    listStorageFilesByOwner(ownerUniqueId: string, ownerType: string, params?: ListStorageFilesParams): Observable<PageResult<StorageFile>>;
+    listEntityFiles(params?: ListEntityFilesParams): Observable<PageResult<EntityFile>>;
+    getEntityFile(uniqueId: string): Observable<EntityFile>;
+    attachFile(data: AttachFileRequest): Observable<EntityFile>;
+    detachFile(uniqueId: string): Observable<void>;
+    updateEntityFile(uniqueId: string, data: UpdateEntityFileRequest): Observable<EntityFile>;
+    reorderEntityFiles(entityUniqueId: string, entityType: string, data: ReorderFilesRequest): Observable<EntityFile[]>;
+    listEntityFilesByEntity(entityUniqueId: string, entityType: string, params?: ListEntityFilesParams): Observable<PageResult<EntityFile>>;
+    listFileSchemas(params?: ListFileSchemasParams): Observable<PageResult<FileSchema>>;
+    getFileSchema(uniqueId: string): Observable<FileSchema>;
+    getFileSchemaByCode(code: string): Observable<FileSchema>;
+    createFileSchema(data: CreateFileSchemaRequest): Observable<FileSchema>;
+    updateFileSchema(uniqueId: string, data: UpdateFileSchemaRequest): Observable<FileSchema>;
+    deleteFileSchema(uniqueId: string): Observable<void>;
+    /**
+     * List user files
+     */
+    listUserFiles(userUniqueId: string, params?: ListUserFilesParams): Observable<PageResult<UserFile>>;
+    /**
+     * Get a user file
+     */
+    getUserFile(userUniqueId: string, fileUniqueId: string): Observable<UserFile>;
+    /**
+     * Add a user file
+     */
+    addUserFile(userUniqueId: string, data: AddUserFileRequest): Observable<UserFile>;
+    /**
+     * Update a user file
+     */
+    updateUserFile(userUniqueId: string, fileUniqueId: string, data: UpdateUserFileRequest): Observable<UserFile>;
+    /**
+     * Delete a user file
+     */
+    deleteUserFile(userUniqueId: string, fileUniqueId: string): Observable<void>;
+    /**
+     * Get presigned upload URL for user file
+     */
+    presignUserFileUpload(userUniqueId: string, data: PresignUploadRequest): Observable<PresignUploadResponse>;
+    /**
+     * Get presigned URLs for multipart upload
+     */
+    multipartPresignUserFile(userUniqueId: string, data: MultipartPresignRequest$1): Observable<MultipartPresignResponse$1>;
+    /**
+     * Complete multipart upload for user file
+     */
+    multipartCompleteUserFile(userUniqueId: string, data: MultipartCompleteRequest$1): Observable<UserFile>;
+    /**
+     * Approve a user file
+     */
+    approveUserFile(userUniqueId: string, fileUniqueId: string): Observable<UserFile>;
+    /**
+     * Reject a user file
+     */
+    rejectUserFile(userUniqueId: string, fileUniqueId: string): Observable<UserFile>;
+    /**
+     * Publish a user file
+     */
+    publishUserFile(userUniqueId: string, fileUniqueId: string): Observable<UserFile>;
+    /**
+     * Unpublish a user file
+     */
+    unpublishUserFile(userUniqueId: string, fileUniqueId: string): Observable<UserFile>;
+    /**
+     * Add tag to user file
+     */
+    addTagToUserFile(userUniqueId: string, fileUniqueId: string, tagUniqueId: string): Observable<UserFile>;
+    /**
+     * Remove tag from user file
+     */
+    removeTagFromUserFile(userUniqueId: string, fileUniqueId: string, tagUniqueId: string): Observable<void>;
+    /**
+     * Bulk update tags for user files
+     */
+    bulkUpdateUserFileTags(userUniqueId: string, tagUniqueIds: string[]): Observable<void>;
+    /**
+     * Request access to a user file
+     */
+    requestUserFileAccess(userUniqueId: string, fileUniqueId: string): Observable<void>;
+    /**
+     * Get access list for a user file
+     */
+    getUserFileAccess(userUniqueId: string, fileUniqueId: string): Observable<FileAccess[]>;
+    /**
+     * Grant access to a user file
+     */
+    grantUserFileAccess(userUniqueId: string, fileUniqueId: string, data: FileAccessRequest): Observable<FileAccess>;
+    /**
+     * Revoke access to a user file
+     */
+    revokeUserFileAccess(userUniqueId: string, fileUniqueId: string, accessUniqueId: string): Observable<void>;
+    /**
+     * Make user file public
+     */
+    makeUserFilePublic(userUniqueId: string, fileUniqueId: string): Observable<UserFile>;
+    /**
+     * Make user file private
+     */
+    makeUserFilePrivate(userUniqueId: string, fileUniqueId: string): Observable<UserFile>;
+    /**
+     * Bulk grant access to user files
+     */
+    bulkGrantUserFileAccess(userUniqueId: string, fileUniqueIds: string[], granteeUniqueIds: string[]): Observable<void>;
+    /**
+     * Bulk revoke access to user files
+     */
+    bulkRevokeUserFileAccess(userUniqueId: string, fileUniqueIds: string[], granteeUniqueIds: string[]): Observable<void>;
+    /**
+     * List access requests for a user file
+     */
+    listUserFileAccessRequests(userUniqueId: string, fileUniqueId: string): Observable<FileAccess[]>;
+    /**
+     * Approve access request for a user file
+     */
+    approveUserFileAccessRequest(userUniqueId: string, fileUniqueId: string, requestUniqueId: string): Observable<FileAccess>;
+    /**
+     * Deny access request for a user file
+     */
+    denyUserFileAccessRequest(userUniqueId: string, fileUniqueId: string, requestUniqueId: string): Observable<void>;
+    /**
+     * List granted delegations for a user
+     */
+    listUserGrantedDelegations(userUniqueId: string): Observable<FileDelegation[]>;
+    /**
+     * List received delegations for a user
+     */
+    listUserReceivedDelegations(userUniqueId: string): Observable<FileDelegation[]>;
+    /**
+     * Get a user delegation
+     */
+    getUserDelegation(userUniqueId: string, delegationUniqueId: string): Observable<FileDelegation>;
+    /**
+     * Create a user delegation
+     */
+    createUserDelegation(userUniqueId: string, data: CreateDelegationRequest): Observable<FileDelegation>;
+    /**
+     * Revoke a user delegation
+     */
+    revokeUserDelegation(userUniqueId: string, delegationUniqueId: string): Observable<void>;
+    /**
+     * List file categories
+     */
+    listFileCategories(params?: ListFileCategoriesParams): Observable<PageResult<FileCategory>>;
+    /**
+     * Get a file category
+     */
+    getFileCategory(uniqueId: string): Observable<FileCategory>;
+    /**
+     * Create a file category
+     */
+    createFileCategory(data: CreateFileCategoryRequest): Observable<FileCategory>;
+    /**
+     * Update a file category
+     */
+    updateFileCategory(uniqueId: string, data: UpdateFileCategoryRequest): Observable<FileCategory>;
+    /**
+     * Delete a file category
+     */
+    deleteFileCategory(uniqueId: string): Observable<void>;
+    /**
+     * List children of a file category
+     */
+    listFileCategoryChildren(parentUniqueId: string): Observable<FileCategory[]>;
+    /**
+     * List file tags
+     */
+    listFileTags(params?: ListFileTagsParams): Observable<PageResult<FileTag>>;
+    /**
+     * Get a file tag
+     */
+    getFileTag(uniqueId: string): Observable<FileTag>;
+    /**
+     * Create a file tag
+     */
+    createFileTag(data: CreateFileTagRequest): Observable<FileTag>;
+    /**
+     * Update a file tag
+     */
+    updateFileTag(uniqueId: string, data: UpdateFileTagRequest): Observable<FileTag>;
+    /**
+     * Delete a file tag
+     */
+    deleteFileTag(uniqueId: string): Observable<void>;
+    /**
+     * Add a tag to a file
+     */
+    addFileTag(userUniqueId: string, fileUniqueId: string, tagUniqueId: string): Observable<void>;
+    /**
+     * Remove a tag from a file
+     */
+    removeFileTag(userUniqueId: string, fileUniqueId: string, tagUniqueId: string): Observable<void>;
+    /**
+     * List file delegations for a user
+     */
+    listDelegations(userUniqueId: string, params?: ListFileDelegationsParams): Observable<PageResult<FileDelegation>>;
+    /**
+     * Get a file delegation
+     */
+    getDelegation(userUniqueId: string, uniqueId: string): Observable<FileDelegation>;
+    /**
+     * Create a file delegation
+     */
+    createDelegation(userUniqueId: string, data: CreateFileDelegationRequest): Observable<FileDelegation>;
+    /**
+     * Update a file delegation
+     */
+    updateDelegation(userUniqueId: string, uniqueId: string, data: UpdateFileDelegationRequest): Observable<FileDelegation>;
+    /**
+     * Delete a file delegation
+     */
+    deleteDelegation(userUniqueId: string, uniqueId: string): Observable<void>;
+    /**
+     * List received delegations for a user
+     */
+    listReceivedDelegations(userUniqueId: string): Observable<FileDelegation[]>;
+    /**
+     * List file accesses
+     */
+    listFileAccess(params?: ListFileAccessParams): Observable<PageResult<FileAccess>>;
+    /**
+     * Get a file access
+     */
+    getFileAccess(uniqueId: string): Observable<FileAccess>;
+    /**
+     * Grant file access
+     */
+    grantFileAccess(data: CreateFileAccessRequest): Observable<FileAccess>;
+    /**
+     * Update file access
+     */
+    updateFileAccess(uniqueId: string, data: UpdateFileAccessRequest): Observable<FileAccess>;
+    /**
+     * Revoke file access
+     */
+    revokeFileAccess(uniqueId: string): Observable<void>;
+    /**
+     * List file accesses by file
+     */
+    listFileAccessByFile(fileUniqueId: string, params?: ListFileAccessParams): Observable<PageResult<FileAccess>>;
+    /**
+     * List file accesses by grantee
+     */
+    listFileAccessByGrantee(granteeUniqueId: string, granteeType: string, params?: ListFileAccessParams): Observable<PageResult<FileAccess>>;
+    /**
+     * Check if a grantee has access to a file
+     */
+    checkFileAccess(fileUniqueId: string, granteeUniqueId: string): Observable<FileAccess | null>;
+    /**
+     * List file access requests
+     */
+    listFileAccessRequests(params?: ListFileAccessRequestsParams): Observable<PageResult<FileAccessRequest>>;
+    /**
+     * Get a file access request
+     */
+    getFileAccessRequest(uniqueId: string): Observable<FileAccessRequest>;
+    /**
+     * Create a file access request
+     */
+    createFileAccessRequest(data: CreateFileAccessRequestInput): Observable<FileAccessRequest>;
+    /**
+     * Review (approve/reject) a file access request
+     */
+    reviewFileAccessRequest(uniqueId: string, review: ReviewFileAccessRequestInput): Observable<FileAccessRequest>;
+    /**
+     * Cancel a file access request
+     */
+    cancelFileAccessRequest(uniqueId: string): Observable<void>;
+    /**
+     * List access requests for a file
+     */
+    listAccessRequestsByFile(fileUniqueId: string, params?: ListFileAccessRequestsParams): Observable<PageResult<FileAccessRequest>>;
+    /**
+     * List access requests by requester
+     */
+    listAccessRequestsByRequester(requesterUniqueId: string, params?: ListFileAccessRequestsParams): Observable<PageResult<FileAccessRequest>>;
+    /**
+     * Get pending access requests count
+     */
+    getPendingAccessRequestsCount(): Observable<number>;
+    /**
+     * Access the underlying block for advanced operations
+     * Use this when you need access to services not wrapped by this Angular service
+     */
+    get filesBlock(): FilesBlock;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilesService, [{ optional: true; }, { optional: true; }, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FilesService>;
+}
+
+/**
+ * Angular service wrapping the Forms block.
+ * Converts Promise-based APIs to RxJS Observables.
+ *
+ * @example
+ * ```typescript
+ * @Component({...})
+ * export class FormComponent {
+ *   constructor(private formsService: FormsService) {}
+ *
+ *   loadForms() {
+ *     this.formsService.listForms().subscribe({
+ *       next: (result) => console.log('Forms:', result.data),
+ *       error: (err) => console.error('Failed:', err),
+ *     });
+ *   }
+ * }
+ * ```
+ */
+declare class FormsService {
+    private readonly block;
+    constructor(serviceTransport: Transport | null, legacyTransport: Transport | null, config: FormsBlockConfig);
+    /**
+     * Ensure the service is configured, throw helpful error if not
+     */
+    private ensureConfigured;
+    listForms(params?: ListFormsParams): Observable<PageResult<Form>>;
+    getForm(uniqueId: string): Observable<Form>;
+    createForm(data: CreateFormRequest): Observable<Form>;
+    updateForm(uniqueId: string, data: UpdateFormRequest): Observable<Form>;
+    deleteForm(uniqueId: string): Observable<void>;
+    listFormSchemas(params?: ListFormSchemasParams): Observable<PageResult<FormSchema>>;
+    getFormSchema(uniqueId: string): Observable<FormSchema>;
+    createFormSchema(data: CreateFormSchemaRequest): Observable<FormSchema>;
+    updateFormSchema(uniqueId: string, data: UpdateFormSchemaRequest): Observable<FormSchema>;
+    deleteFormSchema(uniqueId: string): Observable<void>;
+    getLatestFormSchemaVersion(formUniqueId: string): Observable<FormSchema>;
+    listFormSchemaVersions(formSchemaUniqueId: string, params?: ListFormSchemaVersionsParams): Observable<PageResult<FormSchemaVersion>>;
+    getFormSchemaVersion(formSchemaUniqueId: string, uniqueId: string): Observable<FormSchemaVersion>;
+    createFormSchemaVersion(formSchemaUniqueId: string, data: CreateFormSchemaVersionRequest): Observable<FormSchemaVersion>;
+    updateFormSchemaVersion(formSchemaUniqueId: string, uniqueId: string, data: UpdateFormSchemaVersionRequest): Observable<FormSchemaVersion>;
+    deleteFormSchemaVersion(formSchemaUniqueId: string, uniqueId: string): Observable<void>;
+    listFormInstances(params?: ListFormInstancesParams): Observable<PageResult<FormInstance>>;
+    getFormInstance(uniqueId: string): Observable<FormInstance>;
+    createFormInstance(data: CreateFormInstanceRequest): Observable<FormInstance>;
+    updateFormInstance(uniqueId: string, data: UpdateFormInstanceRequest): Observable<FormInstance>;
+    deleteFormInstance(uniqueId: string): Observable<void>;
+    submitFormInstance(data: SubmitFormInstanceRequest): Observable<FormInstance>;
+    listFormInstancesByUser(userUniqueId: string, params?: ListFormInstancesParams): Observable<PageResult<FormInstance>>;
+    listFormInstancesBySchema(formSchemaUniqueId: string, params?: ListFormInstancesParams): Observable<PageResult<FormInstance>>;
+    listFormSets(params?: ListFormSetsParams): Observable<PageResult<FormSet>>;
+    getFormSet(uniqueId: string): Observable<FormSet>;
+    createFormSet(data: CreateFormSetRequest): Observable<FormSet>;
+    updateFormSet(uniqueId: string, data: UpdateFormSetRequest): Observable<FormSet>;
+    deleteFormSet(uniqueId: string): Observable<void>;
+    listLandings(formUniqueId: string, params?: ListLandingsParams): Observable<PageResult<Landing>>;
+    getLanding(formUniqueId: string, uniqueId: string): Observable<Landing>;
+    submitLanding(formUniqueId: string, data: CreateLandingRequest): Observable<Landing>;
+    updateLanding(formUniqueId: string, uniqueId: string, data: UpdateLandingRequest): Observable<Landing>;
+    deleteLanding(formUniqueId: string, uniqueId: string): Observable<void>;
+    listSubscriptions(formUniqueId: string, params?: ListSubscriptionsParams): Observable<PageResult<Subscription>>;
+    getSubscription(formUniqueId: string, uniqueId: string): Observable<Subscription>;
+    submitSubscription(formUniqueId: string, data: CreateSubscriptionRequest): Observable<Subscription>;
+    updateSubscription(formUniqueId: string, uniqueId: string, data: UpdateSubscriptionRequest): Observable<Subscription>;
+    deleteSubscription(formUniqueId: string, uniqueId: string): Observable<void>;
+    listAppointments(formUniqueId: string, params?: ListAppointmentsParams): Observable<PageResult<Appointment>>;
+    getAppointment(formUniqueId: string, uniqueId: string): Observable<Appointment>;
+    createAppointment(formUniqueId: string, data: CreateAppointmentRequest): Observable<Appointment>;
+    updateAppointment(formUniqueId: string, uniqueId: string, data: UpdateAppointmentRequest): Observable<Appointment>;
+    deleteAppointment(formUniqueId: string, uniqueId: string): Observable<void>;
+    confirmAppointment(formUniqueId: string, uniqueId: string): Observable<Appointment>;
+    cancelAppointment(formUniqueId: string, uniqueId: string): Observable<Appointment>;
+    getAppointmentReportList(data: AppointmentReportRequest): Observable<Appointment[]>;
+    getAppointmentReportSummary(data: AppointmentReportRequest): Observable<AppointmentReportSummary>;
+    listSurveys(formUniqueId: string, params?: ListSurveysParams): Observable<PageResult<Survey>>;
+    listSurveysByStatus(formUniqueId: string, status: SurveyStatus, params?: ListSurveysParams): Observable<PageResult<Survey>>;
+    getSurvey(formUniqueId: string, uniqueId: string): Observable<Survey>;
+    createSurvey(formUniqueId: string, data: CreateSurveyRequest): Observable<Survey>;
+    updateSurvey(formUniqueId: string, uniqueId: string, data: UpdateSurveyRequest): Observable<Survey>;
+    deleteSurvey(formUniqueId: string, uniqueId: string): Observable<void>;
+    updateSurveyStatus(formUniqueId: string, uniqueId: string, data: UpdateSurveyStatusRequest): Observable<Survey>;
+    resendSurveyMagicLink(formUniqueId: string, uniqueId: string): Observable<void>;
+    listSurveysByUser(userUniqueId: string, params?: ListSurveysParams): Observable<PageResult<Survey>>;
+    listReferrals(formUniqueId: string, params?: ListReferralsParams$1): Observable<PageResult<Referral$1>>;
+    getReferral(formUniqueId: string, uniqueId: string): Observable<Referral$1>;
+    createReferral(formUniqueId: string, data: CreateReferralRequest$1): Observable<Referral$1>;
+    updateReferral(formUniqueId: string, uniqueId: string, data: UpdateReferralRequest$1): Observable<Referral$1>;
+    deleteReferral(formUniqueId: string, uniqueId: string): Observable<void>;
+    listMailTemplates(params?: ListMailTemplatesParams): Observable<PageResult<MailTemplate$1>>;
+    getMailTemplate(uniqueId: string): Observable<MailTemplate$1>;
+    createMailTemplate(data: CreateMailTemplateRequest): Observable<MailTemplate$1>;
+    updateMailTemplate(uniqueId: string, data: UpdateMailTemplateRequest): Observable<MailTemplate$1>;
+    deleteMailTemplate(uniqueId: string): Observable<void>;
+    /**
+     * Get public form via magic link.
+     * If OTP verification is required, returns form with verificationStatus: 'pending'
+     * and limited fields (no schema/uiSchema until verified).
+     */
+    getApplicationForm(urlId: string): Observable<ApplicationForm>;
+    submitApplicationForm(urlId: string, data: ApplicationFormSubmission): Observable<ApplicationFormResponse>;
+    saveApplicationFormDraft(urlId: string, data: ApplicationFormDraft): Observable<ApplicationFormResponse>;
+    /**
+     * Send OTP verification code to user's email.
+     * @throws Error with code RATE_LIMITED if called too frequently (60s cooldown)
+     * @throws Error with code ALREADY_VERIFIED if form is already verified
+     * @throws Error with code OTP_NOT_REQUIRED if form doesn't require OTP
+     */
+    sendApplicationFormOtp(urlId: string): Observable<SendOtpResponse>;
+    /**
+     * Verify OTP code and get full form access.
+     * On success, returns full form with schema and fields.
+     * @throws Error with code INVALID_CODE if code is wrong (includes attemptsRemaining)
+     * @throws Error with code CODE_EXPIRED if code has expired (10 min lifetime)
+     * @throws Error with code ATTEMPTS_EXCEEDED if max attempts (5) reached
+     */
+    verifyApplicationFormOtp(urlId: string, data: VerifyOtpRequest): Observable<ApplicationForm>;
+    syncLandingToCrm(uniqueId: string): Observable<CrmSyncResult>;
+    syncSubscriptionToCrm(uniqueId: string): Observable<CrmSyncResult>;
+    syncAppointmentToCrm(uniqueId: string): Observable<CrmSyncResult>;
+    batchSyncToCrm(data: CrmSyncBatchRequest): Observable<CrmSyncBatchResult>;
+    retryFailedCrmSync(): Observable<CrmSyncBatchResult>;
+    testCrmConnection(): Observable<CrmConnectionStatus>;
+    getCrmSyncStatus(): Observable<CrmSyncStatus>;
+    /**
+     * Access the underlying FormsBlock for advanced operations
+     */
+    get formsBlock(): FormsBlock;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormsService, [{ optional: true; }, { optional: true; }, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormsService>;
+}
+
+/**
+ * Angular service wrapping the Assets block.
+ * Converts Promise-based APIs to RxJS Observables.
+ *
+ * @example
+ * ```typescript
+ * @Component({...})
+ * export class AssetManagementComponent {
+ *   constructor(private assets: AssetsService) {}
+ *
+ *   loadAssets() {
+ *     this.assets.listAssets().subscribe({
+ *       next: (result) => console.log('Assets:', result.data),
+ *       error: (err) => console.error('Failed:', err),
+ *     });
+ *   }
+ * }
+ * ```
+ */
+declare class AssetsService {
+    private readonly block;
+    constructor(serviceTransport: Transport | null, legacyTransport: Transport | null, config: AssetsBlockConfig);
+    /**
+     * Ensure the service is configured, throw helpful error if not
+     */
+    private ensureConfigured;
+    listAssets(params?: ListAssetsParams): Observable<PageResult<Asset>>;
+    getAsset(uniqueId: string): Observable<Asset>;
+    createAsset(data: CreateAssetRequest): Observable<Asset>;
+    updateAsset(uniqueId: string, data: UpdateAssetRequest): Observable<Asset>;
+    deleteAsset(uniqueId: string): Observable<void>;
+    listAssetsTrash(): Observable<PageResult<Asset>>;
+    transferAsset(uniqueId: string, data: TransferAssetRequest): Observable<Asset>;
+    assignAsset(uniqueId: string, data: AssignAssetRequest): Observable<Asset>;
+    unassignAsset(uniqueId: string): Observable<Asset>;
+    listAssetsByLocation(locationUniqueId: string, params?: ListAssetsParams): Observable<PageResult<Asset>>;
+    listAssetsByAssignee(assignedToUniqueId: string, params?: ListAssetsParams): Observable<PageResult<Asset>>;
+    addAssetToCategory(uniqueId: string, data: AddToCategoryRequest): Observable<Asset>;
+    addAssetParts(uniqueId: string, data: AddPartsRequest): Observable<Asset>;
+    removeAssetParts(uniqueId: string, data: RemovePartsRequest): Observable<Asset>;
+    updateAssetMaintenance(uniqueId: string, data: UpdateMaintenanceRequest): Observable<Asset>;
+    lendAsset(uniqueId: string, data: LendAssetRequest): Observable<Asset>;
+    createAssetOTP(uniqueId: string, data?: CreateOTPRequest): Observable<OTPResponse>;
+    listAssetEvents(assetUniqueId: string, params?: ListAssetEventsParams): Observable<PageResult<AssetEvent>>;
+    getAssetEvent(assetUniqueId: string, eventUniqueId: string): Observable<AssetEvent>;
+    createAssetEvent(assetUniqueId: string, data: CreateAssetEventRequest): Observable<AssetEvent>;
+    updateAssetEvent(assetUniqueId: string, eventUniqueId: string, data: UpdateAssetEventRequest): Observable<AssetEvent>;
+    getEventReportList(params: EventReportParams): Observable<EventReportList>;
+    getEventReportSummary(params: EventReportParams): Observable<EventReportSummary>;
+    presignEventImage(assetUniqueId: string, eventUniqueId: string): Observable<EventImagePresignResponse>;
+    createEventImage(assetUniqueId: string, eventUniqueId: string, data: CreateEventImageRequest): Observable<EventImage>;
+    deleteEventImage(assetUniqueId: string, eventUniqueId: string, imageUniqueId: string): Observable<void>;
+    listAssetAudits(assetUniqueId: string, params?: ListAssetAuditsParams): Observable<PageResult<AssetAudit>>;
+    getAssetAudit(assetUniqueId: string, auditUniqueId: string): Observable<AssetAudit>;
+    createAssetAudit(assetUniqueId: string, data: CreateAssetAuditRequest): Observable<AssetAudit>;
+    updateAssetAudit(assetUniqueId: string, auditUniqueId: string, data: UpdateAssetAuditRequest): Observable<AssetAudit>;
+    deleteAssetAudit(assetUniqueId: string, auditUniqueId: string): Observable<void>;
+    listCategories(params?: ListCategoriesParams$3): Observable<PageResult<Category$3>>;
+    getCategory(uniqueId: string): Observable<Category$3>;
+    createCategory(data: CreateCategoryRequest$3): Observable<Category$3>;
+    updateCategory(uniqueId: string, data: UpdateCategoryRequest$3): Observable<Category$3>;
+    deleteCategory(uniqueId: string): Observable<void>;
+    deleteCategoryCascade(uniqueId: string): Observable<void>;
+    presignCategoryImage(uniqueId: string): Observable<CategoryPresignResponse>;
+    createCategoryImage(uniqueId: string, data: CreateCategoryImageRequest): Observable<CategoryImage>;
+    deleteCategoryImage(uniqueId: string, imageUniqueId: string): Observable<void>;
+    listTags(params?: ListTagsParams$1): Observable<PageResult<Tag$1>>;
+    getTag(uniqueId: string): Observable<Tag$1>;
+    createTag(data: CreateTagRequest$1): Observable<Tag$1>;
+    updateTag(uniqueId: string, data: UpdateTagRequest$1): Observable<Tag$1>;
+    listVendors(params?: ListVendorsParams$1): Observable<PageResult<Vendor$1>>;
+    getVendor(uniqueId: string): Observable<Vendor$1>;
+    createVendor(data: CreateVendorRequest$1): Observable<Vendor$1>;
+    updateVendor(uniqueId: string, data: UpdateVendorRequest$1): Observable<Vendor$1>;
+    deleteVendor(uniqueId: string): Observable<void>;
+    listWarehouses(params?: ListWarehousesParams$1): Observable<PageResult<Warehouse$1>>;
+    getWarehouse(uniqueId: string): Observable<Warehouse$1>;
+    createWarehouse(data: CreateWarehouseRequest$1): Observable<Warehouse$1>;
+    updateWarehouse(uniqueId: string, data: UpdateWarehouseRequest$1): Observable<Warehouse$1>;
+    deleteWarehouse(uniqueId: string): Observable<void>;
+    listEntities(params?: ListAssetsEntitiesParams): Observable<PageResult<AssetsEntity>>;
+    getEntity(uniqueId: string): Observable<AssetsEntity>;
+    createEntity(data: CreateAssetsEntityRequest): Observable<AssetsEntity>;
+    updateEntity(uniqueId: string, data: UpdateAssetsEntityRequest): Observable<AssetsEntity>;
+    deleteEntity(uniqueId: string): Observable<void>;
+    listEntityAccesses(uniqueId: string): Observable<EntityAccess[]>;
+    getEntityAccess(uniqueId: string): Observable<EntityAccess>;
+    makeEntityPublic(uniqueId: string): Observable<void>;
+    revokeEntityAccess(uniqueId: string, accessUniqueId: string): Observable<void>;
+    requestEntityAccess(uniqueId: string, data: CreateAccessRequestRequest): Observable<AccessRequest>;
+    listEntityAccessRequests(uniqueId: string): Observable<AccessRequest[]>;
+    approveEntityAccessRequest(uniqueId: string, requestUniqueId: string): Observable<AccessRequest>;
+    denyEntityAccessRequest(uniqueId: string, requestUniqueId: string): Observable<void>;
+    listAssetOperations(assetUniqueId: string, params?: ListAssetOperationsParams): Observable<PageResult<AssetOperation>>;
+    getAssetOperation(assetUniqueId: string, operationUniqueId: string): Observable<AssetOperation>;
+    createAssetOperation(assetUniqueId: string, data: CreateAssetOperationRequest): Observable<AssetOperation>;
+    getOperationReportSummary(params: OperationReportParams): Observable<OperationReportSummary>;
+    getAlert(uniqueId: string): Observable<AssetAlert>;
+    createAlert(data: CreateAssetAlertRequest): Observable<AssetAlert>;
+    deleteAlert(uniqueId: string): Observable<void>;
+    listAssetsUsers(params?: ListAssetsUsersParams): Observable<PageResult<AssetsUser>>;
+    getAssetsUser(uniqueId: string): Observable<AssetsUser>;
+    registerAssetsUser(uniqueId: string, data: RegisterAssetsUserRequest): Observable<AssetsUser>;
+    updateAssetsUser(uniqueId: string, data: UpdateAssetsUserRequest): Observable<AssetsUser>;
+    listUserEntities(uniqueId: string): Observable<AssetsEntity[]>;
+    listUserAssets(uniqueId: string): Observable<Asset[]>;
+    listUserOwnership(uniqueId: string): Observable<UserOwnership[]>;
+    presignAssetImage(assetUniqueId: string): Observable<AssetPresignResponse>;
+    createAssetImage(assetUniqueId: string, data: CreateAssetImageRequest): Observable<AssetImage>;
+    deleteAssetImage(assetUniqueId: string, imageUniqueId: string): Observable<void>;
+    presignAssetEventImage(assetUniqueId: string, eventUniqueId: string): Observable<AssetPresignResponse>;
+    createAssetEventImage(assetUniqueId: string, eventUniqueId: string, data: CreateAssetImageRequest): Observable<AssetImage>;
+    deleteAssetEventImage(assetUniqueId: string, eventUniqueId: string, imageUniqueId: string): Observable<void>;
+    /**
+     * Access the underlying block for advanced operations
+     * Use this when you need access to services not wrapped by this Angular service
+     */
+    get assetsBlock(): AssetsBlock;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AssetsService, [{ optional: true; }, { optional: true; }, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AssetsService>;
+}
+
+/**
+ * Angular service wrapping the Campaigns block.
+ * Converts Promise-based APIs to RxJS Observables.
+ *
+ * @example
+ * ```typescript
+ * @Component({...})
+ * export class CampaignsComponent {
+ *   constructor(private campaigns: CampaignsService) {}
+ *
+ *   loadCampaigns() {
+ *     this.campaigns.listCampaigns({ page: 1, perPage: 10 }).subscribe({
+ *       next: (result) => console.log('Campaigns:', result.data),
+ *       error: (err) => console.error('Failed:', err),
+ *     });
+ *   }
+ * }
+ * ```
+ */
+declare class CampaignsService {
+    private readonly block;
+    constructor(serviceTransport: Transport | null, legacyTransport: Transport | null, config: CampaignsBlockConfig);
+    /**
+     * Ensure the service is configured, throw helpful error if not
+     */
+    private ensureConfigured;
+    listCampaigns(params?: ListCampaignsParams): Observable<PageResult<Campaign>>;
+    getCampaign(uniqueId: string): Observable<Campaign>;
+    createCampaign(data: CreateCampaignRequest): Observable<Campaign>;
+    updateCampaign(uniqueId: string, data: UpdateCampaignRequest): Observable<Campaign>;
+    deleteCampaign(uniqueId: string): Observable<void>;
+    startCampaign(uniqueId: string): Observable<Campaign>;
+    pauseCampaign(uniqueId: string): Observable<Campaign>;
+    stopCampaign(uniqueId: string): Observable<Campaign>;
+    getCampaignResults(uniqueId: string): Observable<CampaignResults>;
+    listCampaignMedia(params?: ListCampaignMediaParams): Observable<PageResult<CampaignMedia>>;
+    getCampaignMedia(uniqueId: string): Observable<CampaignMedia>;
+    createCampaignMedia(data: CreateCampaignMediaRequest): Observable<CampaignMedia>;
+    updateCampaignMedia(uniqueId: string, data: UpdateCampaignMediaRequest): Observable<CampaignMedia>;
+    deleteCampaignMedia(uniqueId: string): Observable<void>;
+    listCampaignMediaByCampaign(campaignUniqueId: string): Observable<CampaignMedia[]>;
+    getCampaignMediaResults(uniqueId: string): Observable<CampaignMediaResults>;
+    listLandingPages(params?: ListLandingPagesParams): Observable<PageResult<LandingPage>>;
+    getLandingPage(uniqueId: string): Observable<LandingPage>;
+    createLandingPage(data: CreateLandingPageRequest): Observable<LandingPage>;
+    updateLandingPage(uniqueId: string, data: UpdateLandingPageRequest): Observable<LandingPage>;
+    deleteLandingPage(uniqueId: string): Observable<void>;
+    publishLandingPage(uniqueId: string): Observable<LandingPage>;
+    unpublishLandingPage(uniqueId: string): Observable<LandingPage>;
+    getLandingPageBySlug(slug: string): Observable<LandingPage>;
+    listAudiences(params?: ListAudiencesParams): Observable<PageResult<Audience>>;
+    getAudience(uniqueId: string): Observable<Audience>;
+    createAudience(data: CreateAudienceRequest): Observable<Audience>;
+    updateAudience(uniqueId: string, data: UpdateAudienceRequest): Observable<Audience>;
+    deleteAudience(uniqueId: string): Observable<void>;
+    getAudienceMembers(uniqueId: string): Observable<AudienceMember[]>;
+    listLandingTemplates(params?: ListLandingTemplatesParams): Observable<PageResult<LandingTemplate>>;
+    getLandingTemplate(uniqueId: string): Observable<LandingTemplate>;
+    createLandingTemplate(data: CreateLandingTemplateRequest): Observable<LandingTemplate>;
+    updateLandingTemplate(uniqueId: string, data: UpdateLandingTemplateRequest): Observable<LandingTemplate>;
+    deleteLandingTemplate(uniqueId: string): Observable<void>;
+    listCampaignTargets(params?: ListCampaignTargetsParams): Observable<PageResult<CampaignTarget>>;
+    getCampaignTarget(uniqueId: string): Observable<CampaignTarget>;
+    createCampaignTarget(data: CreateCampaignTargetRequest): Observable<CampaignTarget>;
+    updateCampaignTarget(uniqueId: string, data: UpdateCampaignTargetRequest): Observable<CampaignTarget>;
+    deleteCampaignTarget(uniqueId: string): Observable<void>;
+    listCampaignResultsData(params?: ListCampaignResultsParams): Observable<PageResult<CampaignResult>>;
+    getCampaignResult(uniqueId: string): Observable<CampaignResult>;
+    createCampaignResult(data: CreateCampaignResultRequest): Observable<CampaignResult>;
+    updateCampaignResult(uniqueId: string, data: UpdateCampaignResultRequest): Observable<CampaignResult>;
+    deleteCampaignResult(uniqueId: string): Observable<void>;
+    listCampaignMarkets(params?: ListCampaignMarketsParams): Observable<PageResult<CampaignMarket>>;
+    getCampaignMarket(uniqueId: string): Observable<CampaignMarket>;
+    createCampaignMarket(data: CreateCampaignMarketRequest): Observable<CampaignMarket>;
+    updateCampaignMarket(uniqueId: string, data: UpdateCampaignMarketRequest): Observable<CampaignMarket>;
+    deleteCampaignMarket(uniqueId: string): Observable<void>;
+    listCampaignLocations(params?: ListCampaignLocationsParams): Observable<PageResult<CampaignLocation>>;
+    getCampaignLocation(uniqueId: string): Observable<CampaignLocation>;
+    createCampaignLocation(data: CreateCampaignLocationRequest): Observable<CampaignLocation>;
+    updateCampaignLocation(uniqueId: string, data: UpdateCampaignLocationRequest): Observable<CampaignLocation>;
+    deleteCampaignLocation(uniqueId: string): Observable<void>;
+    listCampaignTemplates(params?: ListCampaignTemplatesParams): Observable<PageResult<CampaignTemplate>>;
+    getCampaignTemplate(uniqueId: string): Observable<CampaignTemplate>;
+    createCampaignTemplate(data: CreateCampaignTemplateRequest): Observable<CampaignTemplate>;
+    updateCampaignTemplate(uniqueId: string, data: UpdateCampaignTemplateRequest): Observable<CampaignTemplate>;
+    deleteCampaignTemplate(uniqueId: string): Observable<void>;
+    listTemplateDetails(params?: ListTemplateDetailsParams): Observable<PageResult<TemplateDetail>>;
+    getTemplateDetail(uniqueId: string): Observable<TemplateDetail>;
+    createTemplateDetail(data: CreateTemplateDetailRequest): Observable<TemplateDetail>;
+    updateTemplateDetail(uniqueId: string, data: UpdateTemplateDetailRequest): Observable<TemplateDetail>;
+    deleteTemplateDetail(uniqueId: string): Observable<void>;
+    listCampaignMediaResultsData(params?: ListCampaignMediaResultsParams): Observable<PageResult<CampaignMediaResult>>;
+    getCampaignMediaResultData(uniqueId: string): Observable<CampaignMediaResult>;
+    createCampaignMediaResultData(data: CreateCampaignMediaResultRequest): Observable<CampaignMediaResult>;
+    updateCampaignMediaResultData(uniqueId: string, data: UpdateCampaignMediaResultRequest): Observable<CampaignMediaResult>;
+    deleteCampaignMediaResultData(uniqueId: string): Observable<void>;
+    listMedia(params?: ListMediaParams): Observable<PageResult<Media>>;
+    getMedia(uniqueId: string): Observable<Media>;
+    createMedia(data: CreateMediaRequest): Observable<Media>;
+    updateMedia(uniqueId: string, data: UpdateMediaRequest): Observable<Media>;
+    deleteMedia(uniqueId: string): Observable<void>;
+    /**
+     * Access the underlying block for advanced operations
+     * Use this when you need access to services not wrapped by this Angular service
+     */
+    get campaignsBlock(): CampaignsBlock;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CampaignsService, [{ optional: true; }, { optional: true; }, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CampaignsService>;
+}
+
+/**
+ * Angular service wrapping the Company block.
+ * Converts Promise-based APIs to RxJS Observables.
+ *
+ * @example
+ * ```typescript
+ * @Component({...})
+ * export class CompanyComponent {
+ *   constructor(private company: CompanyService) {}
+ *
+ *   createCompany(name: string) {
+ *     this.company.createCompany({ name, code: 'COMP001' }).subscribe({
+ *       next: (company) => console.log('Company created:', company),
+ *       error: (err) => console.error('Failed:', err),
+ *     });
+ *   }
+ * }
+ * ```
+ */
+declare class CompanyService {
+    private readonly block;
+    constructor(serviceTransport: Transport | null, legacyTransport: Transport | null, config: CompanyBlockConfig);
+    /**
+     * Ensure the service is configured, throw helpful error if not
+     */
+    private ensureConfigured;
+    listCompanies(params?: ListCompaniesParams): Observable<PageResult<Company$1>>;
+    getCompany(uniqueId: string): Observable<Company$1>;
+    createCompany(request: CreateCompanyRequest): Observable<Company$1>;
+    updateCompany(uniqueId: string, request: UpdateCompanyRequest): Observable<Company$1>;
+    deleteCompany(uniqueId: string): Observable<void>;
+    listDepartments(params?: ListDepartmentsParams): Observable<PageResult<Department>>;
+    getDepartment(uniqueId: string): Observable<Department>;
+    createDepartment(request: CreateDepartmentRequest): Observable<Department>;
+    updateDepartment(uniqueId: string, request: UpdateDepartmentRequest): Observable<Department>;
+    deleteDepartment(uniqueId: string): Observable<void>;
+    listDepartmentsByCompany(companyUniqueId: string): Observable<Department[]>;
+    getDepartmentHierarchy(companyUniqueId: string): Observable<DepartmentHierarchy[]>;
+    listTeams(params?: ListTeamsParams): Observable<PageResult<Team>>;
+    getTeam(uniqueId: string): Observable<Team>;
+    createTeam(request: CreateTeamRequest): Observable<Team>;
+    updateTeam(uniqueId: string, request: UpdateTeamRequest): Observable<Team>;
+    deleteTeam(uniqueId: string): Observable<void>;
+    listTeamsByDepartment(departmentUniqueId: string): Observable<Team[]>;
+    listTeamMembers(params?: ListTeamMembersParams): Observable<PageResult<TeamMember>>;
+    getTeamMember(uniqueId: string): Observable<TeamMember>;
+    addTeamMember(request: AddTeamMemberRequest): Observable<TeamMember>;
+    updateTeamMember(uniqueId: string, request: UpdateTeamMemberRequest): Observable<TeamMember>;
+    removeTeamMember(uniqueId: string): Observable<void>;
+    listTeamMembersByTeam(teamUniqueId: string): Observable<TeamMember[]>;
+    listQuarters(params?: ListQuartersParams): Observable<PageResult<Quarter>>;
+    getQuarter(uniqueId: string): Observable<Quarter>;
+    createQuarter(request: CreateQuarterRequest): Observable<Quarter>;
+    updateQuarter(uniqueId: string, request: UpdateQuarterRequest): Observable<Quarter>;
+    deleteQuarter(uniqueId: string): Observable<void>;
+    /**
+     * List positions with optional filtering and pagination
+     */
+    listPositions(params?: ListPositionsParams): Observable<PageResult<Position>>;
+    /**
+     * Get a position by unique ID
+     */
+    getPosition(uniqueId: string): Observable<Position>;
+    /**
+     * Create a new position
+     */
+    createPosition(request: CreatePositionRequest): Observable<Position>;
+    /**
+     * Update an existing position
+     */
+    updatePosition(uniqueId: string, request: UpdatePositionRequest): Observable<Position>;
+    /**
+     * Delete a position
+     */
+    deletePosition(uniqueId: string): Observable<void>;
+    /**
+     * List positions by department
+     */
+    listPositionsByDepartment(departmentUniqueId: string): Observable<Position[]>;
+    /**
+     * List employee assignments with optional filtering and pagination
+     */
+    listEmployeeAssignments(params?: ListEmployeeAssignmentsParams): Observable<PageResult<EmployeeAssignment>>;
+    /**
+     * Get an employee assignment by unique ID
+     */
+    getEmployeeAssignment(uniqueId: string): Observable<EmployeeAssignment>;
+    /**
+     * Create a new employee assignment
+     */
+    createEmployeeAssignment(request: CreateEmployeeAssignmentRequest): Observable<EmployeeAssignment>;
+    /**
+     * Update an existing employee assignment
+     */
+    updateEmployeeAssignment(uniqueId: string, request: UpdateEmployeeAssignmentRequest): Observable<EmployeeAssignment>;
+    /**
+     * Delete an employee assignment
+     */
+    deleteEmployeeAssignment(uniqueId: string): Observable<void>;
+    /**
+     * List employee assignments by user
+     */
+    listEmployeeAssignmentsByUser(userUniqueId: string): Observable<EmployeeAssignment[]>;
+    /**
+     * List employee assignments by position
+     */
+    listEmployeeAssignmentsByPosition(positionUniqueId: string): Observable<EmployeeAssignment[]>;
+    /**
+     * Access the underlying block for advanced operations
+     * Use this when you need access to services not wrapped by this Angular service
+     */
+    get companyBlock(): CompanyBlock;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CompanyService, [{ optional: true; }, { optional: true; }, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CompanyService>;
+}
+
+/**
+ * Angular service wrapping the Rewards block.
+ * Converts Promise-based APIs to RxJS Observables.
+ *
+ * @example
+ * ```typescript
+ * @Component({...})
+ * export class RewardsComponent {
+ *   constructor(private rewards: RewardsService) {}
+ *
+ *   listRewards() {
+ *     this.rewards.listRewards({ status: 'active' }).subscribe({
+ *       next: (result) => console.log('Rewards:', result.data),
+ *       error: (err) => console.error('Failed:', err),
+ *     });
+ *   }
+ * }
+ * ```
+ */
+declare class RewardsService {
+    private readonly block;
+    constructor(serviceTransport: Transport | null, legacyTransport: Transport | null, config: RewardsBlockConfig);
+    /**
+     * Ensure the service is configured, throw helpful error if not
+     */
+    private ensureConfigured;
+    listRewards(params?: ListRewardsParams): Observable<PageResult<Reward>>;
+    getReward(uniqueId: string): Observable<Reward>;
+    createReward(data: CreateRewardRequest): Observable<Reward>;
+    updateReward(uniqueId: string, data: UpdateRewardRequest): Observable<Reward>;
+    deleteReward(uniqueId: string): Observable<void>;
+    redeemReward(data: RedeemRewardRequest): Observable<RewardRedemption>;
+    listCoupons(params?: ListCouponsParams): Observable<PageResult<Coupon>>;
+    getCoupon(uniqueId: string): Observable<Coupon>;
+    getCouponByCode(code: string): Observable<Coupon>;
+    createCoupon(data: CreateCouponRequest): Observable<Coupon>;
+    updateCoupon(uniqueId: string, data: UpdateCouponRequest): Observable<Coupon>;
+    deleteCoupon(uniqueId: string): Observable<void>;
+    validateCoupon(data: ValidateCouponRequest): Observable<CouponValidationResult>;
+    applyCoupon(data: ApplyCouponRequest): Observable<CouponApplication>;
+    getLoyalty(uniqueId: string): Observable<Loyalty>;
+    getLoyaltyByUser(userUniqueId: string): Observable<Loyalty>;
+    addPoints(data: AddPointsRequest): Observable<LoyaltyTransaction>;
+    redeemPoints(data: RedeemPointsRequest): Observable<LoyaltyTransaction>;
+    getLoyaltyHistory(userUniqueId: string, params?: ListTransactionsParams): Observable<PageResult<LoyaltyTransaction>>;
+    listBadges(params?: ListBadgesParams): Observable<PageResult<Badge>>;
+    getBadge(uniqueId: string): Observable<Badge>;
+    createBadge(data: CreateBadgeRequest): Observable<Badge>;
+    updateBadge(uniqueId: string, data: UpdateBadgeRequest): Observable<Badge>;
+    deleteBadge(uniqueId: string): Observable<void>;
+    awardBadge(data: AwardBadgeRequest): Observable<UserBadge>;
+    listUserBadges(userUniqueId: string, params?: ListUserBadgesParams): Observable<PageResult<UserBadge>>;
+    listCouponConfigurations(params?: ListCouponConfigurationsParams): Observable<PageResult<CouponConfiguration>>;
+    getCouponConfiguration(uniqueId: string): Observable<CouponConfiguration>;
+    createCouponConfiguration(data: CreateCouponConfigurationRequest): Observable<CouponConfiguration>;
+    updateCouponConfiguration(data: UpdateCouponConfigurationRequest): Observable<CouponConfiguration>;
+    deleteCouponConfiguration(uniqueId: string): Observable<void>;
+    listConfigurationCoupons(uniqueId: string): Observable<Coupon[]>;
+    generateOneCoupon(uniqueId: string): Observable<Coupon>;
+    generateBatchCoupons(uniqueId: string, count: number): Observable<Coupon[]>;
+    voidBatchCoupons(uniqueId: string, batchId: string): Observable<void>;
+    loadCoupons(uniqueId: string, codes: string[]): Observable<Coupon[]>;
+    getOfferCode(code: string): Observable<OfferCode>;
+    createOfferCode(data: CreateOfferCodeRequest): Observable<OfferCode>;
+    sendOfferCode(data: SendOfferCodeRequest): Observable<OfferCode>;
+    redeemOfferCode(data: RedeemOfferCodeRequest): Observable<OfferCode>;
+    listExpirationRules(params?: ListExpirationRulesParams): Observable<PageResult<ExpirationRule>>;
+    getExpirationRule(uniqueId: string): Observable<ExpirationRule>;
+    createExpirationRule(data: CreateExpirationRuleRequest): Observable<ExpirationRule>;
+    updateExpirationRule(uniqueId: string, data: UpdateExpirationRuleRequest): Observable<ExpirationRule>;
+    deleteExpirationRule(uniqueId: string): Observable<void>;
+    listRewardsCustomers(params?: ListRewardsCustomersParams): Observable<PageResult<RewardsCustomer>>;
+    getRewardsCustomer(uniqueId: string): Observable<RewardsCustomer>;
+    getCustomerLoyaltyTier(uniqueId: string): Observable<Loyalty>;
+    getCustomerRewards(uniqueId: string): Observable<unknown>;
+    getCustomerRewardExpirations(uniqueId: string): Observable<CustomerRewardExpiration[]>;
+    getCustomerRewardHistory(uniqueId: string): Observable<CustomerRewardHistory[]>;
+    getCustomerBadges(uniqueId: string): Observable<Badge[]>;
+    getCustomerCoupons(uniqueId: string): Observable<Coupon[]>;
+    getCustomerOfferCodes(uniqueId: string): Observable<OfferCode[]>;
+    grantCustomerReward(uniqueId: string, points: number, reason?: string): Observable<RewardsCustomer>;
+    updateCustomerExpiration(uniqueId: string, expirationDate: Date): Observable<RewardsCustomer>;
+    /**
+     * List badge categories with optional pagination
+     */
+    listBadgeCategories(page?: number, perPage?: number): Observable<PageResult<BadgeCategory>>;
+    /**
+     * Get a badge category by unique ID
+     */
+    getBadgeCategory(uniqueId: string): Observable<BadgeCategory>;
+    /**
+     * Create a new badge category
+     */
+    createBadgeCategory(data: CreateBadgeCategoryRequest): Observable<BadgeCategory>;
+    /**
+     * Update a badge category
+     */
+    updateBadgeCategory(uniqueId: string, data: Partial<CreateBadgeCategoryRequest>): Observable<BadgeCategory>;
+    /**
+     * Delete a badge category
+     */
+    deleteBadgeCategory(uniqueId: string): Observable<void>;
+    /**
+     * List money rules for a loyalty program
+     */
+    listMoneyRules(loyaltyUniqueId: string): Observable<MoneyRule[]>;
+    /**
+     * Get a money rule by unique ID
+     */
+    getMoneyRule(loyaltyUniqueId: string, ruleUniqueId: string): Observable<MoneyRule>;
+    /**
+     * Create a new money rule
+     */
+    createMoneyRule(loyaltyUniqueId: string, data: CreateMoneyRuleRequest): Observable<MoneyRule>;
+    /**
+     * Update a money rule
+     */
+    updateMoneyRule(loyaltyUniqueId: string, ruleUniqueId: string, data: UpdateMoneyRuleRequest): Observable<MoneyRule>;
+    /**
+     * Delete a money rule
+     */
+    deleteMoneyRule(loyaltyUniqueId: string, ruleUniqueId: string): Observable<void>;
+    /**
+     * List product rules for a loyalty program
+     */
+    listProductRules(loyaltyUniqueId: string): Observable<ProductRule[]>;
+    /**
+     * Get a product rule by unique ID
+     */
+    getProductRule(loyaltyUniqueId: string, ruleUniqueId: string): Observable<ProductRule>;
+    /**
+     * Create a new product rule
+     */
+    createProductRule(loyaltyUniqueId: string, data: CreateProductRuleRequest): Observable<ProductRule>;
+    /**
+     * Update a product rule
+     */
+    updateProductRule(loyaltyUniqueId: string, ruleUniqueId: string, data: UpdateProductRuleRequest): Observable<ProductRule>;
+    /**
+     * Delete a product rule
+     */
+    deleteProductRule(loyaltyUniqueId: string, ruleUniqueId: string): Observable<void>;
+    /**
+     * List event rules for a loyalty program
+     */
+    listEventRules(loyaltyUniqueId: string): Observable<EventRule[]>;
+    /**
+     * Get an event rule by unique ID
+     */
+    getEventRule(loyaltyUniqueId: string, ruleUniqueId: string): Observable<EventRule>;
+    /**
+     * Create a new event rule
+     */
+    createEventRule(loyaltyUniqueId: string, data: CreateEventRuleRequest): Observable<EventRule>;
+    /**
+     * Update an event rule
+     */
+    updateEventRule(loyaltyUniqueId: string, ruleUniqueId: string, data: UpdateEventRuleRequest): Observable<EventRule>;
+    /**
+     * Delete an event rule
+     */
+    deleteEventRule(loyaltyUniqueId: string, ruleUniqueId: string): Observable<void>;
+    /**
+     * Access the underlying block for advanced operations
+     * Use this when you need access to services not wrapped by this Angular service
+     */
+    get rewardsBlock(): RewardsBlock;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RewardsService, [{ optional: true; }, { optional: true; }, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RewardsService>;
+}
+
+/**
+ * Angular service wrapping the Sales block.
+ * Converts Promise-based APIs to RxJS Observables.
+ *
+ * @example
+ * ```typescript
+ * @Component({...})
+ * export class CheckoutComponent {
+ *   constructor(private sales: SalesService) {}
+ *
+ *   createOrder(items: any[]) {
+ *     this.sales.createOrder({ userUniqueId: '123', items }).subscribe({
+ *       next: (order) => console.log('Order created:', order),
+ *       error: (err) => console.error('Failed:', err),
+ *     });
+ *   }
+ * }
+ * ```
+ */
+declare class SalesService {
+    private readonly block;
+    constructor(serviceTransport: Transport | null, legacyTransport: Transport | null, config: SalesBlockConfig);
+    /**
+     * Ensure the service is configured, throw helpful error if not
+     */
+    private ensureConfigured;
+    listOrders(params?: ListOrdersParams): Observable<PageResult<Order>>;
+    getOrder(uniqueId: string): Observable<Order>;
+    createOrder(data: CreateOrderRequest): Observable<Order>;
+    updateOrder(uniqueId: string, data: UpdateOrderRequest): Observable<Order>;
+    cancelOrder(uniqueId: string): Observable<Order>;
+    confirmOrder(uniqueId: string): Observable<Order>;
+    shipOrder(uniqueId: string, trackingNumber?: string): Observable<Order>;
+    deliverOrder(uniqueId: string): Observable<Order>;
+    listOrdersByUser(userUniqueId: string, params?: ListOrdersParams): Observable<PageResult<Order>>;
+    listOrderDetails(): Observable<OrderDetail[]>;
+    getOrderDetail(uniqueId: string): Observable<OrderDetail>;
+    updateOrderDetail(uniqueId: string, data: UpdateOrderDetailRequest): Observable<OrderDetail>;
+    listOrderDetailsByOrder(orderUniqueId: string): Observable<OrderDetail[]>;
+    listPayments(params?: ListPaymentsParams): Observable<PageResult<Payment>>;
+    getPayment(uniqueId: string): Observable<Payment>;
+    createPayment(data: CreatePaymentRequest): Observable<Payment>;
+    refundPayment(uniqueId: string, amount?: number): Observable<Payment>;
+    listPaymentsByOrder(orderUniqueId: string): Observable<Payment[]>;
+    listSubscriptions(params?: ListSubscriptionsParams$1): Observable<PageResult<Subscription$1>>;
+    getSubscription(uniqueId: string): Observable<Subscription$1>;
+    createSubscription(data: CreateSubscriptionRequest$1): Observable<Subscription$1>;
+    updateSubscription(uniqueId: string, data: UpdateSubscriptionRequest$1): Observable<Subscription$1>;
+    cancelSubscription(uniqueId: string): Observable<Subscription$1>;
+    pauseSubscription(uniqueId: string): Observable<Subscription$1>;
+    resumeSubscription(uniqueId: string): Observable<Subscription$1>;
+    listSubscriptionsByUser(userUniqueId: string, params?: ListSubscriptionsParams$1): Observable<PageResult<Subscription$1>>;
+    listOrderTaxes(orderUniqueId: string): Observable<OrderTax[]>;
+    getOrderTax(orderUniqueId: string, uniqueId: string): Observable<OrderTax>;
+    createOrderTax(orderUniqueId: string, data: CreateOrderTaxRequest): Observable<OrderTax>;
+    updateOrderTax(orderUniqueId: string, uniqueId: string, data: UpdateOrderTaxRequest): Observable<OrderTax>;
+    deleteOrderTax(orderUniqueId: string, uniqueId: string): Observable<void>;
+    listSubscriptionModels(params?: ListSubscriptionModelsParams): Observable<PageResult<SubscriptionModel$1>>;
+    getSubscriptionModel(uniqueId: string): Observable<SubscriptionModel$1>;
+    createSubscriptionModel(data: CreateSubscriptionModelRequest): Observable<SubscriptionModel$1>;
+    updateSubscriptionModel(uniqueId: string, data: UpdateSubscriptionModelRequest): Observable<SubscriptionModel$1>;
+    listSalesEntities(params?: ListSalesEntitiesParams): Observable<PageResult<SalesEntity>>;
+    getSalesEntity(uniqueId: string): Observable<SalesEntity>;
+    registerSalesEntity(uniqueId: string, data?: RegisterSalesEntityRequest): Observable<SalesEntity>;
+    updateSalesEntity(uniqueId: string, data: UpdateSalesEntityRequest): Observable<SalesEntity>;
+    createEntitySubscription(uniqueId: string, data: CreateEntitySubscriptionRequest): Observable<EntitySubscription>;
+    updateEntitySubscription(uniqueId: string, subscriptionUniqueId: string, data: UpdateEntitySubscriptionRequest): Observable<EntitySubscription>;
+    listSalesUsers(params?: ListSalesUsersParams): Observable<PageResult<SalesUser>>;
+    getSalesUser(uniqueId: string): Observable<SalesUser>;
+    registerSalesUser(uniqueId: string, data?: RegisterSalesUserRequest): Observable<SalesUser>;
+    updateSalesUser(uniqueId: string, data: UpdateSalesUserRequest): Observable<SalesUser>;
+    createSalesUserSubscription(uniqueId: string, data: CreateUserSubscriptionRequest): Observable<UserSubscription$1>;
+    updateSalesUserSubscription(uniqueId: string, subscriptionUniqueId: string, data: UpdateUserSubscriptionRequest): Observable<UserSubscription$1>;
+    listSalesCustomers(params?: ListSalesCustomersParams): Observable<PageResult<SalesCustomer>>;
+    getSalesCustomer(uniqueId: string): Observable<SalesCustomer>;
+    createSalesCustomer(data: CreateSalesCustomerRequest): Observable<SalesCustomer>;
+    updateSalesCustomer(uniqueId: string, data: UpdateSalesCustomerRequest): Observable<SalesCustomer>;
+    listFlexibleOrders(params?: ListFlexibleOrdersParams): Observable<PageResult<FlexibleOrder>>;
+    getFlexibleOrder(uniqueId: string): Observable<FlexibleOrder>;
+    createFlexibleOrder(data: CreateFlexibleOrderRequest): Observable<FlexibleOrder>;
+    updateFlexibleOrder(uniqueId: string, data: UpdateFlexibleOrderRequest): Observable<FlexibleOrder>;
+    listVendorPayments(params?: ListVendorPaymentsParams): Observable<PageResult<VendorPayment>>;
+    getVendorPayment(uniqueId: string): Observable<VendorPayment>;
+    createVendorPayment(data: CreateVendorPaymentRequest): Observable<VendorPayment>;
+    updateVendorPayment(uniqueId: string, data: UpdateVendorPaymentRequest): Observable<VendorPayment>;
+    /**
+     * Create a Stripe customer
+     */
+    createStripeCustomer(data: CreateStripeCustomerRequest): Observable<CreateStripeCustomerResponse>;
+    /**
+     * Create a Stripe checkout session
+     */
+    createStripeCheckoutSession(data: CreateStripeCheckoutSessionRequest): Observable<StripeCheckoutSession>;
+    /**
+     * Create a Stripe payment intent
+     */
+    createStripePaymentIntent(data: CreateStripePaymentIntentRequest): Observable<StripePaymentIntent>;
+    /**
+     * Create a Stripe customer portal session
+     */
+    createStripeCustomerPortal(uniqueId: string, data: CreateStripeCustomerPortalRequest): Observable<StripeCustomerPortalSession>;
+    /**
+     * List Stripe subscriptions
+     */
+    listStripeSubscriptions(params?: ListStripeSubscriptionsParams): Observable<PageResult<StripeSubscription>>;
+    /**
+     * Create a Stripe subscription
+     */
+    createStripeSubscription(data: CreateStripeSubscriptionRequest): Observable<StripeSubscription>;
+    /**
+     * Update a Stripe subscription
+     */
+    updateStripeSubscription(stripeSubscriptionId: string, data: UpdateStripeSubscriptionRequest): Observable<StripeSubscription>;
+    /**
+     * Cancel a Stripe subscription
+     */
+    cancelStripeSubscription(stripeSubscriptionId: string): Observable<void>;
+    /**
+     * List Stripe webhooks
+     */
+    listStripeWebhooks(): Observable<StripeWebhook[]>;
+    /**
+     * Create a Stripe webhook
+     */
+    createStripeWebhook(data: CreateStripeWebhookRequest): Observable<StripeWebhook>;
+    /**
+     * List available MercadoPago payment methods
+     */
+    listMercadoPagoPaymentMethods(): Observable<MercadoPagoPaymentMethod[]>;
+    /**
+     * Create a MercadoPago payment intent
+     */
+    createMercadoPagoPaymentIntent(data: CreateMercadoPagoPaymentRequest): Observable<MercadoPagoPaymentIntent>;
+    /**
+     * Create a MercadoPago PSE payment intent (Colombia bank transfer)
+     */
+    createMercadoPagoPSEIntent(data: CreateMercadoPagoPSERequest): Observable<MercadoPagoPaymentIntent>;
+    /**
+     * Access the underlying block for advanced operations
+     * Use this when you need access to services not wrapped by this Angular service
+     */
+    get salesBlock(): SalesBlock;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SalesService, [{ optional: true; }, { optional: true; }, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SalesService>;
+}
+
+/**
+ * Angular service wrapping the Wallet block.
+ * Converts Promise-based APIs to RxJS Observables.
+ *
+ * @example
+ * ```typescript
+ * @Component({...})
+ * export class WalletComponent {
+ *   constructor(private wallet: WalletService) {}
+ *
+ *   createWallet(userUniqueId: string) {
+ *     this.wallet.createWallet({ userUniqueId }).subscribe({
+ *       next: (wallet) => console.log('Created:', wallet),
+ *       error: (err) => console.error('Failed:', err),
+ *     });
+ *   }
+ * }
+ * ```
+ */
+declare class WalletService {
+    private readonly block;
+    constructor(serviceTransport: Transport | null, legacyTransport: Transport | null, config: WalletBlockConfig);
+    /**
+     * Ensure the service is configured, throw helpful error if not
+     */
+    private ensureConfigured;
+    listWallets(params?: ListWalletsParams): Observable<PageResult<Wallet>>;
+    getWallet(uniqueId: string): Observable<Wallet>;
+    getWalletByUser(userUniqueId: string): Observable<Wallet>;
+    createWallet(data: CreateWalletRequest): Observable<Wallet>;
+    updateWallet(uniqueId: string, data: UpdateWalletRequest): Observable<Wallet>;
+    creditWallet(uniqueId: string, data: CreditWalletRequest): Observable<Transaction>;
+    debitWallet(uniqueId: string, data: DebitWalletRequest): Observable<Transaction>;
+    getWalletBalance(uniqueId: string): Observable<{
+        balance: number;
+        currency: string;
+    }>;
+    getUserWallet(userUniqueId: string, walletCode: string): Observable<Wallet>;
+    validateWallet(data: ValidateWalletRequest): Observable<ValidateWalletResponse>;
+    transferWallet(userUniqueId: string, walletCode: string, data: TransferWalletRequest): Observable<Transaction>;
+    getWalletContent(userUniqueId: string, walletCode: string): Observable<WalletContent[]>;
+    storeWalletContent(userUniqueId: string, walletCode: string, data: StoreWalletContentRequest): Observable<WalletContent>;
+    listWalletTransactions(userUniqueId: string, walletCode: string): Observable<PageResult<Transaction>>;
+    listTransactions(params?: ListTransactionsParams$1): Observable<PageResult<Transaction>>;
+    getTransaction(uniqueId: string): Observable<Transaction>;
+    listTransactionsByWallet(walletUniqueId: string, params?: ListTransactionsParams$1): Observable<PageResult<Transaction>>;
+    listTransactionsByReference(referenceType: string, referenceUniqueId: string, params?: ListTransactionsParams$1): Observable<PageResult<Transaction>>;
+    listAuthorizationCodes(params?: ListAuthorizationCodesParams): Observable<PageResult<AuthorizationCode>>;
+    getAuthorizationCode(uniqueId: string): Observable<AuthorizationCode>;
+    createAuthorizationCode(data: CreateAuthorizationCodeRequest): Observable<AuthorizationCode>;
+    validateAuthorizationCode(data: ValidateAuthorizationCodeRequest): Observable<{
+        valid: boolean;
+        authorizationCode?: AuthorizationCode;
+    }>;
+    useAuthorizationCode(data: UseAuthorizationCodeRequest): Observable<Transaction>;
+    invalidateAuthorizationCode(uniqueId: string): Observable<AuthorizationCode>;
+    /**
+     * Process an incoming transaction webhook from an external payment provider.
+     * This endpoint is used to record transactions initiated by external systems.
+     */
+    processTransactionWebhook(companyUrlId: string, walletCode: string, data: TransactionWebhookRequest): Observable<TransactionWebhookResponse>;
+    /**
+     * Access the underlying block for advanced operations
+     * Use this when you need access to services not wrapped by this Angular service
+     */
+    get walletBlock(): WalletBlock;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WalletService, [{ optional: true; }, { optional: true; }, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WalletService>;
+}
+
+/**
+ * Angular service wrapping the Jarvis block.
+ * Converts Promise-based APIs to RxJS Observables.
+ *
+ * @example
+ * ```typescript
+ * @Component({...})
+ * export class ChatComponent {
+ *   constructor(private jarvis: JarvisService) {}
+ *
+ *   sendMessage(agentId: string, message: string) {
+ *     this.jarvis.chat(agentId, { message }).subscribe({
+ *       next: (response) => console.log('Response:', response.response),
+ *       error: (err) => console.error('Failed:', err),
+ *     });
+ *   }
+ * }
+ * ```
+ */
+declare class JarvisService {
+    private readonly block;
+    constructor(serviceTransport: Transport | null, legacyTransport: Transport | null, config: JarvisBlockConfig);
+    /**
+     * Ensure the service is configured, throw helpful error if not
+     */
+    private ensureConfigured;
+    listAgents(params?: ListAgentsParams): Observable<PageResult<Agent>>;
+    getAgent(uniqueId: string): Observable<Agent>;
+    createAgent(data: CreateAgentRequest): Observable<Agent>;
+    updateAgent(uniqueId: string, data: UpdateAgentRequest): Observable<Agent>;
+    deleteAgent(uniqueId: string): Observable<void>;
+    chat(uniqueId: string, data: ChatRequest): Observable<ChatResponse>;
+    complete(uniqueId: string, data: CompleteRequest): Observable<CompleteResponse>;
+    listPrompts(params?: ListPromptsParams): Observable<PageResult<Prompt>>;
+    getPrompt(uniqueId: string): Observable<Prompt>;
+    createPrompt(data: CreatePromptRequest): Observable<Prompt>;
+    updatePrompt(uniqueId: string, data: UpdatePromptRequest): Observable<Prompt>;
+    deletePrompt(uniqueId: string): Observable<void>;
+    executePrompt(uniqueId: string, data: ExecutePromptRequest): Observable<ExecutePromptResponse>;
+    testPrompt(data: TestPromptRequest): Observable<TestPromptResponse>;
+    renderPrompt(uniqueId: string, data: RenderPromptRequest): Observable<RenderPromptResponse>;
+    listWorkflows(params?: ListWorkflowsParams): Observable<PageResult<Workflow>>;
+    getWorkflow(uniqueId: string): Observable<Workflow>;
+    createWorkflow(data: CreateWorkflowRequest): Observable<Workflow>;
+    updateWorkflow(uniqueId: string, data: UpdateWorkflowRequest): Observable<Workflow>;
+    deleteWorkflow(uniqueId: string): Observable<void>;
+    runWorkflow(uniqueId: string, data: RunWorkflowRequest): Observable<RunWorkflowResponse>;
+    pauseWorkflow(uniqueId: string): Observable<Workflow>;
+    resumeWorkflow(uniqueId: string): Observable<Workflow>;
+    listExecutions(params?: ListExecutionsParams): Observable<PageResult<Execution>>;
+    getExecution(uniqueId: string): Observable<Execution>;
+    listExecutionsByAgent(agentUniqueId: string, params?: ListExecutionsParams): Observable<PageResult<Execution>>;
+    listExecutionsByPrompt(promptUniqueId: string, params?: ListExecutionsParams): Observable<PageResult<Execution>>;
+    cancelExecution(uniqueId: string): Observable<Execution>;
+    listConversations(params?: ListConversationsParams): Observable<PageResult<Conversation$1>>;
+    getConversation(uniqueId: string): Observable<Conversation$1>;
+    createConversation(data: CreateConversationRequest): Observable<Conversation$1>;
+    sendMessage(uniqueId: string, data: SendMessageRequest): Observable<SendMessageResponse>;
+    listConversationsByUser(userUniqueId: string, params?: ListConversationsParams): Observable<PageResult<Conversation$1>>;
+    clearConversation(uniqueId: string): Observable<Conversation$1>;
+    listAIModels(params?: ListAIModelsParams): Observable<PageResult<AIModel>>;
+    getAIModel(uniqueId: string): Observable<AIModel>;
+    createAIModel(data: CreateAIModelRequest): Observable<AIModel>;
+    updateAIModel(uniqueId: string, data: UpdateAIModelRequest): Observable<AIModel>;
+    deleteAIModel(uniqueId: string): Observable<void>;
+    listEntities(params?: ListEntitiesParams$1): Observable<PageResult<Entity>>;
+    getEntity(uniqueId: string): Observable<Entity>;
+    registerEntity(uniqueId: string, data?: RegisterEntityRequest$1): Observable<Entity>;
+    updateEntity(uniqueId: string, data: UpdateEntityRequest$1): Observable<Entity>;
+    deleteEntity(uniqueId: string): Observable<void>;
+    addEntityPrompt(uniqueId: string, promptUniqueId: string): Observable<void>;
+    getEntityContext(uniqueId: string, contextUniqueId: string): Observable<EntityContext>;
+    createEntityContext(uniqueId: string, data?: CreateEntityContextRequest): Observable<EntityContext>;
+    getEntityConversation(uniqueId: string, contextUniqueId: string): Observable<EntityContext>;
+    sendEntityMessage(uniqueId: string, contextUniqueId: string, data: SendEntityMessageRequest): Observable<SendEntityMessageResponse>;
+    queryEntityFile(uniqueId: string, fileUniqueId: string, data: QueryEntityFileRequest): Observable<QueryEntityFileResponse>;
+    listClusters(userUniqueId: string, params?: ListClustersParams): Observable<PageResult<Cluster>>;
+    getCluster(userUniqueId: string, uniqueId: string): Observable<Cluster>;
+    createCluster(userUniqueId: string, data: CreateClusterRequest): Observable<Cluster>;
+    updateCluster(userUniqueId: string, uniqueId: string, data: UpdateClusterRequest): Observable<Cluster>;
+    deleteCluster(userUniqueId: string, uniqueId: string): Observable<void>;
+    addClusterMember(userUniqueId: string, uniqueId: string, entityUniqueId: string): Observable<void>;
+    removeClusterMember(userUniqueId: string, uniqueId: string, entityUniqueId: string): Observable<void>;
+    addClusterPrompt(userUniqueId: string, uniqueId: string, promptUniqueId: string): Observable<void>;
+    getClusterContext(userUniqueId: string, uniqueId: string, contextUniqueId: string): Observable<ClusterContext>;
+    createClusterContext(userUniqueId: string, uniqueId: string, data?: CreateClusterContextRequest): Observable<ClusterContext>;
+    getClusterConversation(userUniqueId: string, uniqueId: string, contextUniqueId: string): Observable<ClusterContext>;
+    sendClusterMessage(userUniqueId: string, uniqueId: string, contextUniqueId: string, data: SendClusterMessageRequest): Observable<SendClusterMessageResponse>;
+    listJarvisUsers(params?: ListJarvisUsersParams): Observable<PageResult<JarvisUser>>;
+    getJarvisUser(uniqueId: string): Observable<JarvisUser>;
+    registerJarvisUser(uniqueId: string, data?: RegisterJarvisUserRequest): Observable<JarvisUser>;
+    updateJarvisUser(uniqueId: string, data: UpdateJarvisUserRequest): Observable<JarvisUser>;
+    addJarvisUserPrompt(uniqueId: string, promptUniqueId: string): Observable<void>;
+    getJarvisUserContext(uniqueId: string, contextUniqueId: string): Observable<UserContext>;
+    createJarvisUserContext(uniqueId: string, data?: CreateUserContextRequest): Observable<UserContext>;
+    getJarvisUserConversation(uniqueId: string, contextUniqueId: string): Observable<UserContext>;
+    sendJarvisUserMessage(uniqueId: string, contextUniqueId: string, data: SendUserMessageRequest): Observable<SendUserMessageResponse>;
+    getJarvisUserContentContext(uniqueId: string, contentIdentityUniqueId: string, contextUniqueId: string): Observable<UserContext>;
+    createJarvisUserContentContext(uniqueId: string, contentIdentityUniqueId: string, data?: CreateUserContentContextRequest): Observable<UserContext>;
+    getJarvisUserContentConversation(uniqueId: string, contentIdentityUniqueId: string, contextUniqueId: string): Observable<UserContext>;
+    sendJarvisUserContentMessage(uniqueId: string, contentIdentityUniqueId: string, contextUniqueId: string, data: SendUserMessageRequest): Observable<SendUserMessageResponse>;
+    listWorkflowParticipants(workflowUniqueId: string, params?: ListWorkflowParticipantsParams): Observable<PageResult<WorkflowParticipant>>;
+    getWorkflowParticipant(workflowUniqueId: string, uniqueId: string): Observable<WorkflowParticipant>;
+    addWorkflowParticipant(workflowUniqueId: string, data: AddWorkflowParticipantRequest): Observable<WorkflowParticipant>;
+    updateWorkflowParticipant(workflowUniqueId: string, uniqueId: string, data: UpdateWorkflowParticipantRequest): Observable<WorkflowParticipant>;
+    removeWorkflowParticipant(workflowUniqueId: string, uniqueId: string): Observable<void>;
+    getWorkflowStep(workflowUniqueId: string, stepUniqueId: string): Observable<WorkflowStep>;
+    addWorkflowStep(workflowUniqueId: string, data: AddWorkflowStepRequest): Observable<WorkflowStep>;
+    updateWorkflowStep(workflowUniqueId: string, stepUniqueId: string, data: UpdateWorkflowStepRequest): Observable<WorkflowStep>;
+    removeWorkflowStep(workflowUniqueId: string, stepUniqueId: string): Observable<void>;
+    addStepPrompt(stepUniqueId: string, data: AddStepPromptRequest): Observable<void>;
+    addStepAgent(stepUniqueId: string, data: AddStepAgentRequest): Observable<void>;
+    startWorkflowInstance(workflowUniqueId: string, data?: StartWorkflowRequest): Observable<StartWorkflowResponse>;
+    getWorkflowInstance(workflowUniqueId: string, instanceUniqueId: string): Observable<WorkflowInstance>;
+    getWorkflowInstanceDetails(workflowUniqueId: string, instanceUniqueId: string): Observable<WorkflowInstanceDetails>;
+    stepWorkflowInstance(workflowUniqueId: string, instanceUniqueId: string, data?: StepWorkflowRequest): Observable<WorkflowInstance>;
+    logWorkflowStep(workflowUniqueId: string, instanceUniqueId: string, data: LogWorkflowStepRequest): Observable<WorkflowInstance>;
+    suspendWorkflowInstance(workflowUniqueId: string, instanceUniqueId: string): Observable<WorkflowInstance>;
+    resumeWorkflowInstance(workflowUniqueId: string, instanceUniqueId: string): Observable<WorkflowInstance>;
+    getAgentContext(agentUniqueId: string, contextUniqueId: string): Observable<AgentContext>;
+    createAgentContext(agentUniqueId: string, data?: CreateAgentContextRequest): Observable<AgentContext>;
+    getAgentConversation(agentUniqueId: string, contextUniqueId: string): Observable<{
+        messages: AgentMessage[];
+    }>;
+    getAgentThread(agentUniqueId: string, threadId: string): Observable<AgentThread>;
+    createAgentThread(agentUniqueId: string, data?: CreateAgentThreadRequest): Observable<AgentThread>;
+    sendAgentThreadMessage(agentUniqueId: string, threadId: string, data: SendAgentThreadMessageRequest): Observable<SendAgentThreadMessageResponse>;
+    sendAgentThreadMessageStream(agentUniqueId: string, threadId: string, data: SendAgentThreadMessageRequest): Observable<ReadableStream<string>>;
+    runAgentThread(agentUniqueId: string, threadId: string, data?: RunAgentThreadRequest): Observable<RunAgentThreadResponse>;
+    getAgentRun(agentUniqueId: string, threadId: string, runId: string): Observable<AgentRun>;
+    getAgentMessages(agentUniqueId: string, threadId: string): Observable<AgentMessage[]>;
+    listAgentExecutions(agentUniqueId: string, params?: ListAgentRunExecutionsParams): Observable<PageResult<AgentRunExecution>>;
+    getAgentExecution(agentUniqueId: string, executionUniqueId: string): Observable<AgentRunExecution>;
+    listMailTemplates(params?: ListMailTemplatesParams$1): Observable<PageResult<MailTemplate$2>>;
+    getMailTemplate(uniqueId: string): Observable<MailTemplate$2>;
+    createMailTemplate(data: CreateMailTemplateRequest$1): Observable<MailTemplate$2>;
+    updateMailTemplate(uniqueId: string, data: UpdateMailTemplateRequest$1): Observable<MailTemplate$2>;
+    createMandrillTemplate(uniqueId: string, data?: CreateMandrillTemplateRequest$1): Observable<MailTemplate$2>;
+    updateMandrillTemplate(uniqueId: string, data?: UpdateMandrillTemplateRequest$1): Observable<MailTemplate$2>;
+    publishMandrill(uniqueId: string): Observable<MailTemplate$2>;
+    getMandrillStats(uniqueId: string): Observable<MandrillStats>;
+    marvinChat(data: MarvinChatRequest): Observable<MarvinChatResponse>;
+    marvinChatV2(data: MarvinChatRequest): Observable<MarvinChatResponse>;
+    marvinChatV3(data: MarvinChatRequest): Observable<MarvinChatResponse>;
+    getMarvinContext(uniqueId: string): Observable<MarvinContext>;
+    createMarvinContext(data?: CreateMarvinContextRequest): Observable<MarvinContext>;
+    sendMarvinMessage(contextUniqueId: string, data: SendMarvinMessageRequest): Observable<SendMarvinMessageResponse>;
+    listPromptComments(promptUniqueId: string, params?: ListPromptCommentsParams): Observable<PageResult<PromptComment>>;
+    getPromptComment(promptUniqueId: string, uniqueId: string): Observable<PromptComment>;
+    createPromptComment(promptUniqueId: string, data: CreatePromptCommentRequest): Observable<PromptComment>;
+    updatePromptComment(promptUniqueId: string, uniqueId: string, data: UpdatePromptCommentRequest): Observable<PromptComment>;
+    deletePromptComment(promptUniqueId: string, uniqueId: string): Observable<void>;
+    likePromptComment(promptUniqueId: string, uniqueId: string): Observable<void>;
+    dislikePromptComment(promptUniqueId: string, uniqueId: string): Observable<void>;
+    replyToPromptComment(promptUniqueId: string, uniqueId: string, data: ReplyToCommentRequest): Observable<PromptComment>;
+    followPromptComment(promptUniqueId: string, uniqueId: string): Observable<void>;
+    unfollowPromptComment(promptUniqueId: string, uniqueId: string): Observable<void>;
+    savePromptComment(promptUniqueId: string, uniqueId: string): Observable<void>;
+    unsavePromptComment(promptUniqueId: string, uniqueId: string): Observable<void>;
+    listExecutionComments(promptUniqueId: string, executionUniqueId: string, params?: ListExecutionCommentsParams): Observable<PageResult<ExecutionComment>>;
+    getExecutionComment(promptUniqueId: string, executionUniqueId: string, uniqueId: string): Observable<ExecutionComment>;
+    createExecutionComment(promptUniqueId: string, executionUniqueId: string, data: CreateExecutionCommentRequest): Observable<ExecutionComment>;
+    updateExecutionComment(promptUniqueId: string, executionUniqueId: string, uniqueId: string, data: UpdateExecutionCommentRequest): Observable<ExecutionComment>;
+    deleteExecutionComment(promptUniqueId: string, executionUniqueId: string, uniqueId: string): Observable<void>;
+    likeExecutionComment(promptUniqueId: string, executionUniqueId: string, uniqueId: string): Observable<void>;
+    dislikeExecutionComment(promptUniqueId: string, executionUniqueId: string, uniqueId: string): Observable<void>;
+    replyToExecutionComment(promptUniqueId: string, executionUniqueId: string, uniqueId: string, data: ReplyToCommentRequest): Observable<ExecutionComment>;
+    followExecutionComment(promptUniqueId: string, executionUniqueId: string, uniqueId: string): Observable<void>;
+    unfollowExecutionComment(promptUniqueId: string, executionUniqueId: string, uniqueId: string): Observable<void>;
+    saveExecutionComment(promptUniqueId: string, executionUniqueId: string, uniqueId: string): Observable<void>;
+    unsaveExecutionComment(promptUniqueId: string, executionUniqueId: string, uniqueId: string): Observable<void>;
+    /**
+     * Access the underlying block for advanced operations
+     * Use this when you need access to services not wrapped by this Angular service
+     */
+    get jarvisBlock(): JarvisBlock;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JarvisService, [{ optional: true; }, { optional: true; }, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<JarvisService>;
+}
+
+/**
+ * Angular service wrapping the Onboarding block.
+ * Converts Promise-based APIs to RxJS Observables.
+ *
+ * @example
+ * ```typescript
+ * @Component({...})
+ * export class OnboardingComponent {
+ *   constructor(private onboarding: OnboardingService) {}
+ *
+ *   createOnboarding() {
+ *     this.onboarding.createOnboarding({
+ *       code: 'user-onboarding',
+ *       name: 'User Onboarding',
+ *       steps: []
+ *     }).subscribe({
+ *       next: (onboarding) => console.log('Created:', onboarding),
+ *       error: (err) => console.error('Failed:', err),
+ *     });
+ *   }
+ * }
+ * ```
+ */
+declare class OnboardingService {
+    private readonly block;
+    constructor(serviceTransport: Transport | null, legacyTransport: Transport | null, config: OnboardingBlockConfig);
+    /**
+     * Ensure the service is configured, throw helpful error if not
+     */
+    private ensureConfigured;
+    listOnboardings(params?: ListOnboardingsParams): Observable<PageResult<Onboarding>>;
+    getOnboarding(uniqueId: string): Observable<Onboarding>;
+    createOnboarding(request: CreateOnboardingRequest): Observable<Onboarding>;
+    updateOnboarding(uniqueId: string, request: UpdateOnboardingRequest): Observable<Onboarding>;
+    deleteOnboarding(uniqueId: string): Observable<void>;
+    addOnboardingStep(uniqueId: string, data: AddStepRequest): Observable<OnboardingStep>;
+    updateOnboardingStep(uniqueId: string, stepUniqueId: string, data: UpdateStepRequest): Observable<OnboardingStep>;
+    deleteOnboardingStep(uniqueId: string, stepUniqueId: string): Observable<void>;
+    stepUser(uniqueId: string, userUniqueId: string, stepData?: Record<string, unknown>): Observable<Onboarding>;
+    listFlows(params?: ListFlowsParams): Observable<PageResult<Flow>>;
+    getFlow(uniqueId: string): Observable<Flow>;
+    createFlow(request: CreateFlowRequest): Observable<Flow>;
+    updateFlow(uniqueId: string, request: UpdateFlowRequest): Observable<Flow>;
+    deleteFlow(uniqueId: string): Observable<void>;
+    listFlowsByOnboarding(onboardingUniqueId: string): Observable<Flow[]>;
+    getFlowBySource(uniqueId: string, sourceUniqueId: string): Observable<Flow>;
+    stepFlowBySource(uniqueId: string, sourceUniqueId: string, stepData?: Record<string, unknown>): Observable<Flow>;
+    listUserJourneys(params?: ListUserJourneysParams): Observable<PageResult<UserJourney>>;
+    getUserJourney(uniqueId: string): Observable<UserJourney>;
+    startJourney(request: StartJourneyRequest): Observable<UserJourney>;
+    completeStep(uniqueId: string, request: CompleteStepRequest): Observable<UserJourney>;
+    abandonJourney(uniqueId: string): Observable<UserJourney>;
+    getJourneysByUser(userUniqueId: string): Observable<UserJourney[]>;
+    getJourneyProgress(uniqueId: string): Observable<{
+        progress: number;
+        currentStep?: number;
+        completedSteps?: number[];
+    }>;
+    listJourneyByUserAndOnboarding(userUniqueId: string, onboardingUniqueId: string): Observable<UserJourney>;
+    reportJourneyList(params: UserJourneyReportParams): Observable<UserJourneyReportList>;
+    reportJourneySummary(params: UserJourneyReportParams): Observable<UserJourneyReportSummary>;
+    listUserIdentities(params?: ListUserIdentitiesParams): Observable<PageResult<UserIdentity>>;
+    getUserIdentity(uniqueId: string): Observable<UserIdentity>;
+    createUserIdentity(request: CreateUserIdentityRequest): Observable<UserIdentity>;
+    verifyUserIdentity(uniqueId: string, request: VerifyUserIdentityRequest): Observable<UserIdentity>;
+    deleteUserIdentity(uniqueId: string): Observable<void>;
+    listIdentitiesByUser(userUniqueId: string): Observable<UserIdentity[]>;
+    startOnboard(uniqueId: string, data?: StartOnboardRequest): Observable<OnboardJourney>;
+    getOnboard(uniqueId: string): Observable<OnboardJourney>;
+    getOnboardDetails(uniqueId: string): Observable<OnboardJourneyDetails>;
+    stepOnboard(uniqueId: string, data: StepOnboardRequest): Observable<OnboardJourney>;
+    logOnboard(uniqueId: string, data: LogOnboardRequest): Observable<OnboardJourney>;
+    suspendOnboard(uniqueId: string): Observable<OnboardJourney>;
+    resumeOnboard(uniqueId: string): Observable<OnboardJourney>;
+    listMailTemplates(params?: ListMailTemplatesParams$2): Observable<PageResult<MailTemplate$3>>;
+    getMailTemplate(uniqueId: string): Observable<MailTemplate$3>;
+    createMailTemplate(data: CreateMailTemplateRequest$2): Observable<MailTemplate$3>;
+    updateMailTemplate(uniqueId: string, data: UpdateMailTemplateRequest$2): Observable<MailTemplate$3>;
+    getMandrillStats(uniqueId: string): Observable<MandrillTemplateStats$1>;
+    createMandrillTemplate(uniqueId: string, data: CreateMandrillTemplateRequest$2): Observable<MailTemplate$3>;
+    updateMandrillTemplate(uniqueId: string, data: UpdateMandrillTemplateRequest$2): Observable<MailTemplate$3>;
+    publishMandrill(uniqueId: string): Observable<MailTemplate$3>;
+    listAbandonedJourneys(params?: ListAbandonedJourneysParams): Observable<PageResult<AbandonedJourney>>;
+    /**
+     * Access the underlying block for advanced operations
+     * Use this when you need access to services not wrapped by this Angular service
+     */
+    get onboardingBlock(): OnboardingBlock;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OnboardingService, [{ optional: true; }, { optional: true; }, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OnboardingService>;
+}
+
+/**
+ * Angular service wrapping the University block.
+ * Converts Promise-based APIs to RxJS Observables.
+ *
+ * @example
+ * ```typescript
+ * @Component({...})
+ * export class CourseListComponent {
+ *   constructor(private university: UniversityService) {}
+ *
+ *   loadCourses() {
+ *     this.university.listCourses({ page: 1, perPage: 10 }).subscribe({
+ *       next: (result) => console.log('Courses:', result.data),
+ *       error: (err) => console.error('Failed:', err),
+ *     });
+ *   }
+ * }
+ * ```
+ */
+declare class UniversityService {
+    private readonly block;
+    constructor(serviceTransport: Transport | null, legacyTransport: Transport | null, config: UniversityBlockConfig);
+    /**
+     * Ensure the service is configured, throw helpful error if not
+     */
+    private ensureConfigured;
+    listCourses(params?: ListCoursesParams): Observable<PageResult<Course>>;
+    getCourse(uniqueId: string): Observable<Course>;
+    createCourse(data: CreateCourseRequest): Observable<Course>;
+    updateCourse(uniqueId: string, data: UpdateCourseRequest): Observable<Course>;
+    deleteCourse(uniqueId: string): Observable<void>;
+    publishCourse(uniqueId: string): Observable<Course>;
+    unpublishCourse(uniqueId: string): Observable<Course>;
+    listCoursesByInstructor(instructorUniqueId: string, params?: ListCoursesParams): Observable<PageResult<Course>>;
+    listCoursesByCategory(categoryUniqueId: string, params?: ListCoursesParams): Observable<PageResult<Course>>;
+    listLessons(params?: ListLessonsParams): Observable<PageResult<Lesson>>;
+    getLesson(uniqueId: string): Observable<Lesson>;
+    createLesson(data: CreateLessonRequest): Observable<Lesson>;
+    updateLesson(uniqueId: string, data: UpdateLessonRequest): Observable<Lesson>;
+    deleteLesson(uniqueId: string): Observable<void>;
+    reorderLessons(courseUniqueId: string, data: ReorderLessonsRequest): Observable<Lesson[]>;
+    listLessonsByCourse(courseUniqueId: string, params?: ListLessonsParams): Observable<PageResult<Lesson>>;
+    listEnrollments(params?: ListEnrollmentsParams): Observable<PageResult<Enrollment>>;
+    getEnrollment(uniqueId: string): Observable<Enrollment>;
+    enroll(data: EnrollRequest): Observable<Enrollment>;
+    updateEnrollmentProgress(uniqueId: string, data: UpdateEnrollmentProgressRequest): Observable<Enrollment>;
+    completeEnrollment(uniqueId: string): Observable<Enrollment>;
+    dropEnrollment(uniqueId: string): Observable<Enrollment>;
+    listEnrollmentsByCourse(courseUniqueId: string, params?: ListEnrollmentsParams): Observable<PageResult<Enrollment>>;
+    listEnrollmentsByUser(userUniqueId: string, params?: ListEnrollmentsParams): Observable<PageResult<Enrollment>>;
+    getCertificate(uniqueId: string): Observable<{
+        certificateUrl: string;
+    }>;
+    listAssignments(params?: ListAssignmentsParams): Observable<PageResult<Assignment>>;
+    getAssignment(uniqueId: string): Observable<Assignment>;
+    createAssignment(data: CreateAssignmentRequest): Observable<Assignment>;
+    updateAssignment(uniqueId: string, data: UpdateAssignmentRequest): Observable<Assignment>;
+    deleteAssignment(uniqueId: string): Observable<void>;
+    listAssignmentsByLesson(lessonUniqueId: string, params?: ListAssignmentsParams): Observable<PageResult<Assignment>>;
+    listSubmissions(params?: ListSubmissionsParams): Observable<PageResult<Submission>>;
+    getSubmission(uniqueId: string): Observable<Submission>;
+    submitAssignment(data: SubmitAssignmentRequest): Observable<Submission>;
+    gradeSubmission(uniqueId: string, data: GradeSubmissionRequest): Observable<Submission>;
+    listSubmissionsByAssignment(assignmentUniqueId: string, params?: ListSubmissionsParams): Observable<PageResult<Submission>>;
+    listSubmissionsByUser(userUniqueId: string, params?: ListSubmissionsParams): Observable<PageResult<Submission>>;
+    listSubjects(params?: ListSubjectsParams): Observable<PageResult<Subject>>;
+    getSubject(uniqueId: string): Observable<Subject>;
+    createSubject(data: CreateSubjectRequest): Observable<Subject>;
+    updateSubject(uniqueId: string, data: UpdateSubjectRequest): Observable<Subject>;
+    getSubjectResources(uniqueId: string): Observable<unknown[]>;
+    getSubjectTeacherResources(uniqueId: string, teacherUniqueId: string): Observable<unknown[]>;
+    getSubjectTests(uniqueId: string): Observable<unknown[]>;
+    addSubjectLesson(uniqueId: string, lessonData: {
+        name: string;
+        description?: string;
+    }): Observable<unknown>;
+    addSubjectResource(uniqueId: string, resourceData: unknown): Observable<unknown>;
+    updateSubjectResource(uniqueId: string, resourceUniqueId: string, resourceData: unknown): Observable<unknown>;
+    deleteSubjectResource(uniqueId: string, resourceUniqueId: string): Observable<void>;
+    listTeachers(params?: ListTeachersParams): Observable<PageResult<Teacher>>;
+    listArchivedTeachers(params?: ListTeachersParams): Observable<PageResult<Teacher>>;
+    getTeacher(uniqueId: string): Observable<Teacher>;
+    getTeacherCourses(uniqueId: string): Observable<Course[]>;
+    getTeacherGroups(uniqueId: string): Observable<CourseGroup[]>;
+    getTeacherAvailability(uniqueId: string): Observable<TeacherAvailability[]>;
+    addTeacherAvailability(uniqueId: string, data: CreateAvailabilityRequest): Observable<TeacherAvailability>;
+    updateTeacherAvailability(uniqueId: string, availabilityUniqueId: string, data: UpdateAvailabilityRequest): Observable<TeacherAvailability>;
+    deleteTeacherAvailability(uniqueId: string, availabilityUniqueId: string): Observable<void>;
+    deleteAllTeacherAvailability(uniqueId: string): Observable<void>;
+    getTeacherContentTree(uniqueId: string, courseGroupUniqueId: string): Observable<unknown>;
+    getTeacherStudentContentTree(uniqueId: string, userUniqueId: string, courseGroupUniqueId: string): Observable<unknown>;
+    promoteStudent(teacherUniqueId: string, userUniqueId: string): Observable<unknown>;
+    listStudents(params?: ListStudentsParams): Observable<PageResult<Student>>;
+    listArchivedStudents(params?: ListStudentsParams): Observable<PageResult<Student>>;
+    getStudent(uniqueId: string): Observable<Student>;
+    registerStudent(uniqueId: string, data: RegisterStudentRequest): Observable<Student>;
+    updateStudent(uniqueId: string, data: UpdateStudentRequest): Observable<Student>;
+    archiveStudent(uniqueId: string): Observable<void>;
+    restoreStudent(uniqueId: string): Observable<Student>;
+    getStudentCourses(uniqueId: string): Observable<Course[]>;
+    getStudentAvailableCourses(uniqueId: string): Observable<Course[]>;
+    getStudentGroups(uniqueId: string): Observable<CourseGroup[]>;
+    getStudentContentTree(uniqueId: string, courseGroupUniqueId: string): Observable<unknown>;
+    getStudentAvailability(uniqueId: string): Observable<StudentAvailability[]>;
+    addStudentAvailability(uniqueId: string, data: {
+        dayOfWeek: number;
+        startTime: string;
+        endTime: string;
+        timezone?: string;
+    }): Observable<StudentAvailability>;
+    updateStudentAvailability(uniqueId: string, availabilityUniqueId: string, data: {
+        dayOfWeek?: number;
+        startTime?: string;
+        endTime?: string;
+        timezone?: string;
+    }): Observable<StudentAvailability>;
+    updateStudentAvailabilitySlots(uniqueId: string, slots: {
+        dayOfWeek: number;
+        startTime: string;
+        endTime: string;
+    }[]): Observable<StudentAvailability[]>;
+    deleteStudentAvailability(uniqueId: string, availabilityUniqueId: string): Observable<void>;
+    deleteAllStudentAvailability(uniqueId: string): Observable<void>;
+    getCourseGroup(uniqueId: string): Observable<CourseGroup>;
+    createCourseGroup(data: CreateCourseGroupRequest): Observable<CourseGroup>;
+    addStudentToCourseGroup(uniqueId: string, studentUniqueId: string): Observable<CourseGroup>;
+    addTeacherToCourseGroup(uniqueId: string, teacherUniqueId: string): Observable<CourseGroup>;
+    getCourseGroupTests(uniqueId: string): Observable<unknown[]>;
+    getCourseGroupTestResponses(uniqueId: string, testUniqueId: string): Observable<unknown[]>;
+    listCoachingSessions(params?: ListCoachingSessionsParams): Observable<PageResult<CoachingSession>>;
+    createCoachingSession(data: CreateCoachingSessionRequest): Observable<CoachingSession>;
+    updateCoachingSession(uniqueId: string, data: UpdateCoachingSessionRequest): Observable<CoachingSession>;
+    deleteCoachingSession(uniqueId: string): Observable<void>;
+    getCoachingSessionsByStudent(studentUniqueId: string): Observable<CoachingSession[]>;
+    getCoachingSessionsByTeacher(teacherUniqueId: string): Observable<CoachingSession[]>;
+    studentConfirmCoachingSession(uniqueId: string): Observable<CoachingSession>;
+    studentCheckInCoachingSession(uniqueId: string): Observable<CoachingSession>;
+    studentCheckOutCoachingSession(uniqueId: string): Observable<CoachingSession>;
+    addStudentNotesToCoachingSession(uniqueId: string, notes: string): Observable<CoachingSession>;
+    teacherConfirmCoachingSession(uniqueId: string): Observable<CoachingSession>;
+    teacherCheckInCoachingSession(uniqueId: string): Observable<CoachingSession>;
+    teacherCheckOutCoachingSession(uniqueId: string): Observable<CoachingSession>;
+    addAdminNotesToCoachingSession(uniqueId: string, notes: string): Observable<CoachingSession>;
+    listContentTests(params?: ListContentTestsParams): Observable<PageResult<ContentTest>>;
+    getContentTest(uniqueId: string): Observable<ContentTest>;
+    createContentTest(data: CreateContentTestRequest): Observable<ContentTest>;
+    updateContentTest(uniqueId: string, data: UpdateContentTestRequest): Observable<ContentTest>;
+    getContentTestResults(uniqueId: string): Observable<unknown[]>;
+    getContentTestSolution(uniqueId: string): Observable<unknown>;
+    createTestQuestion(uniqueId: string, data: CreateQuestionRequest): Observable<TestQuestion>;
+    updateTestQuestion(uniqueId: string, questionUniqueId: string, data: Partial<CreateQuestionRequest>): Observable<TestQuestion>;
+    getTestQuestion(uniqueId: string, questionId: string): Observable<TestQuestion>;
+    listTestOptions(): Observable<TestOption[]>;
+    createTestOption(data: CreateOptionRequest): Observable<TestOption>;
+    updateTestOption(uniqueId: string, optionUniqueId: string, data: Partial<CreateOptionRequest>): Observable<TestOption>;
+    addOptionToQuestion(uniqueId: string, questionId: string, optionId: string): Observable<TestQuestion>;
+    listRegistrationTokens(params?: ListRegistrationTokensParams): Observable<PageResult<RegistrationToken>>;
+    getRegistrationToken(uniqueId: string): Observable<RegistrationToken>;
+    createRegistrationToken(data: CreateRegistrationTokenRequest): Observable<RegistrationToken>;
+    updateRegistrationToken(uniqueId: string, data: UpdateRegistrationTokenRequest): Observable<RegistrationToken>;
+    deleteRegistrationToken(uniqueId: string): Observable<void>;
+    validateRegistrationToken(tokenCode: string): Observable<TokenValidationResult>;
+    useRegistrationToken(tokenCode: string, userUniqueId: string): Observable<{
+        success: boolean;
+        enrollmentUniqueId?: string;
+        error?: string;
+    }>;
+    revokeRegistrationToken(uniqueId: string): Observable<RegistrationToken>;
+    generateRegistrationTokenBatch(request: CreateRegistrationTokenRequest & {
+        count: number;
+    }): Observable<RegistrationToken[]>;
+    getPlacement(uniqueId: string): Observable<PlacementTest>;
+    listPlacementsByCourse(courseUniqueId: string, params?: ListPlacementsParams): Observable<PageResult<PlacementTest>>;
+    createPlacement(courseUniqueId: string, data: CreatePlacementRequest): Observable<PlacementTest>;
+    getPlacementSection(placementUniqueId: string, sectionId: string): Observable<PlacementSection>;
+    createPlacementSection(placementUniqueId: string, data: CreatePlacementSectionRequest): Observable<PlacementSection>;
+    getPlacementQuestion(placementUniqueId: string, questionId: string): Observable<PlacementQuestion>;
+    createPlacementQuestion(placementUniqueId: string, data: CreatePlacementQuestionRequest): Observable<PlacementQuestion>;
+    addQuestionToPlacementSection(placementUniqueId: string, sectionId: string, questionId: string): Observable<void>;
+    listPlacementOptions(): Observable<PlacementOption[]>;
+    createPlacementOption(data: CreatePlacementOptionRequest): Observable<PlacementOption>;
+    addOptionToPlacementQuestion(placementUniqueId: string, questionId: string, optionId: string): Observable<void>;
+    setPlacementRightOption(placementUniqueId: string, questionId: string, optionId: string): Observable<void>;
+    removePlacementOption(placementUniqueId: string, questionId: string, optionId: string): Observable<void>;
+    createPlacementRule(placementUniqueId: string, data: CreatePlacementRuleRequest): Observable<PlacementRule>;
+    getUserPlacement(userUniqueId: string): Observable<PlacementInstance | null>;
+    startPlacement(userUniqueId: string, placementUniqueId: string): Observable<PlacementInstance>;
+    submitPlacementResponse(userUniqueId: string, instanceUniqueId: string, responses: PlacementResponse[]): Observable<PlacementInstance>;
+    finishPlacement(userUniqueId: string, instanceUniqueId: string): Observable<PlacementInstance>;
+    getCalendarStudentAvailability(userUniqueId: string): Observable<Availability[]>;
+    addCalendarStudentAvailability(userUniqueId: string, data: CreateAvailabilityRequest): Observable<Availability>;
+    updateCalendarStudentAvailability(userUniqueId: string, availabilityUniqueId: string, data: UpdateAvailabilityRequest): Observable<Availability>;
+    updateCalendarStudentAvailabilities(userUniqueId: string, data: BulkUpdateAvailabilityRequest): Observable<Availability[]>;
+    deleteCalendarStudentAvailability(userUniqueId: string, availabilityUniqueId: string): Observable<void>;
+    deleteAllCalendarStudentAvailability(userUniqueId: string): Observable<void>;
+    getCalendarTeacherAvailability(teacherUniqueId: string): Observable<Availability[]>;
+    addCalendarTeacherAvailability(teacherUniqueId: string, data: CreateAvailabilityRequest): Observable<Availability>;
+    updateCalendarTeacherAvailability(teacherUniqueId: string, availabilityUniqueId: string, data: UpdateAvailabilityRequest): Observable<Availability>;
+    deleteCalendarTeacherAvailability(teacherUniqueId: string, availabilityUniqueId: string): Observable<void>;
+    deleteAllCalendarTeacherAvailability(teacherUniqueId: string): Observable<void>;
+    listCalendarEvents(params?: ListCalendarEventsParams): Observable<PageResult<CalendarEvent>>;
+    getCalendarEvent(uniqueId: string): Observable<CalendarEvent>;
+    createCalendarEvent(data: CreateCalendarEventRequest): Observable<CalendarEvent>;
+    updateCalendarEvent(uniqueId: string, data: UpdateCalendarEventRequest): Observable<CalendarEvent>;
+    deleteCalendarEvent(uniqueId: string): Observable<void>;
+    createMatch(data: CreateMatchRequest): Observable<Match>;
+    activateMatch(uniqueId: string): Observable<Match>;
+    deactivateMatch(uniqueId: string): Observable<Match>;
+    deleteMatch(uniqueId: string): Observable<void>;
+    getActiveMatchByStudent(studentUniqueId: string): Observable<Match | null>;
+    getAllMatchesByStudent(studentUniqueId: string): Observable<Match[]>;
+    getAvailableMatchesByStudent(studentUniqueId: string): Observable<Match[]>;
+    getActiveMatchByTeacher(teacherUniqueId: string): Observable<Match | null>;
+    getAllMatchesByTeacher(teacherUniqueId: string): Observable<Match[]>;
+    getAvailableMatchesByTeacher(teacherUniqueId: string): Observable<Match[]>;
+    findCoaches(studentUniqueId: string, request?: FindCoachesRequest): Observable<AvailableCoach[]>;
+    findCoachees(teacherUniqueId: string, request?: FindCoacheesRequest): Observable<AvailableCoachee[]>;
+    evaluateMatches(request: EvaluateMatchesRequest): Observable<MatchEvaluation[]>;
+    evaluateAvailabilities(request: EvaluateAvailabilitiesRequest): Observable<MatchEvaluation[]>;
+    listAttendance(params?: ListAttendanceParams): Observable<PageResult<Attendance>>;
+    getAttendance(uniqueId: string): Observable<Attendance>;
+    createAttendance(data: CreateAttendanceRequest): Observable<Attendance>;
+    updateAttendance(uniqueId: string, data: UpdateAttendanceRequest): Observable<Attendance>;
+    deleteAttendance(uniqueId: string): Observable<void>;
+    bulkCreateAttendance(data: BulkAttendanceRequest): Observable<Attendance[]>;
+    listAttendanceByLesson(lessonUniqueId: string, params?: ListAttendanceParams): Observable<PageResult<Attendance>>;
+    listAttendanceByStudent(studentUniqueId: string, params?: ListAttendanceParams): Observable<PageResult<Attendance>>;
+    listAttendanceByCourse(courseUniqueId: string, params?: ListAttendanceParams): Observable<PageResult<Attendance>>;
+    getStudentAttendanceStats(studentUniqueId: string, courseUniqueId?: string): Observable<AttendanceStats>;
+    verifyAttendance(uniqueId: string): Observable<Attendance>;
+    listNotes(params?: ListNotesParams): Observable<PageResult<Note>>;
+    getNote(uniqueId: string): Observable<Note>;
+    createNote(data: CreateNoteRequest): Observable<Note>;
+    updateNote(uniqueId: string, data: UpdateNoteRequest): Observable<Note>;
+    deleteNote(uniqueId: string): Observable<void>;
+    listNotesByAuthor(authorUniqueId: string, params?: ListNotesParams): Observable<PageResult<Note>>;
+    listNotesByTarget(targetUniqueId: string, targetType: string, params?: ListNotesParams): Observable<PageResult<Note>>;
+    listNotesByCourse(courseUniqueId: string, params?: ListNotesParams): Observable<PageResult<Note>>;
+    listNotesByLesson(lessonUniqueId: string, params?: ListNotesParams): Observable<PageResult<Note>>;
+    pinNote(uniqueId: string): Observable<Note>;
+    unpinNote(uniqueId: string): Observable<Note>;
+    getNoteReplies(uniqueId: string): Observable<Note[]>;
+    /**
+     * Access the underlying block for advanced operations
+     * Use this when you need access to services not wrapped by this Angular service
+     */
+    get universityBlock(): UniversityBlock;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UniversityService, [{ optional: true; }, { optional: true; }, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UniversityService>;
+}
+
+export { ASSETS_CONFIG, ASSETS_TRANSPORT, AUTHENTICATION_CONFIG, AUTHENTICATION_TRANSPORT, AssetsService, AuthenticationService, CAMPAIGNS_CONFIG, CAMPAIGNS_TRANSPORT, COMPANY_CONFIG, COMPANY_TRANSPORT, CONTENT_CONFIG, CONTENT_TRANSPORT, CONVERSATIONS_CONFIG, CONVERSATIONS_TRANSPORT, CRM_CONFIG, CRM_TRANSPORT, CampaignsService, CompanyService, ContentService, ConversationsService, CrmService, FILES_CONFIG, FILES_TRANSPORT, FORMS_CONFIG, FORMS_TRANSPORT, FilesService, FormsService, GEOLOCATION_CONFIG, GEOLOCATION_TRANSPORT, GeolocationService, JARVIS_CONFIG, JARVIS_TRANSPORT, JarvisService, ONBOARDING_CONFIG, ONBOARDING_TRANSPORT, OnboardingService, PRODUCTS_CONFIG, PRODUCTS_TRANSPORT, PROVIDER_CONFIG, ProductsService, REWARDS_CONFIG, REWARDS_TRANSPORT, RewardsService, SALES_CONFIG, SALES_TRANSPORT, SEARCH_CONFIG, SEARCH_TRANSPORT, SIMPLE_CONFIG, SalesService, SearchService, TOKEN_MANAGER, TRANSPORT, UNIVERSITY_CONFIG, UNIVERSITY_TRANSPORT, UniversityService, WALLET_CONFIG, WALLET_TRANSPORT, WalletService, get23BlocksProviders, getBlocks23Providers, provide23Blocks, provideBlocks23 };
+export type { AuthMode, Provide23BlocksConfig, ProviderConfig, ServiceUrls, Simple23BlocksConfig, StorageType, TokenManagerService };
+//# sourceMappingURL=index.d.ts.map