@burdenoff/microfe-channel 2026.510.112

package/dist/generated/global-operations.d.ts

@@ -0,0 +1,1547 @@
+import * as Types from './global-types';
+import * as Apollo from '@apollo/client';
+import * as ApolloReactHooks from '@apollo/client/react';
+export type ChannelFieldsFragment = {
+    __typename?: 'Channel';
+    id: string;
+    name: string;
+    description?: string | null;
+    platform: Types.ChannelPlatform;
+    adapterType?: Types.AdapterType | null;
+    status: Types.ChannelStatus;
+    priority: number;
+    connectionHealth: Types.ConnectionHealth;
+    lastHealthCheckAt?: string | null;
+    healthCheckError?: string | null;
+    consecutiveFailures: number;
+    organizationId: string;
+    createdBy: string;
+    onBehalfOf: string;
+    platformConfig?: Record<string, unknown> | null;
+    isConnected: boolean;
+    messageCount24h: number;
+    createdAt: string;
+    updatedAt: string;
+    tagAssignments: Array<{
+        __typename?: 'ChannelTagAssignment';
+        id: string;
+        tagId: string;
+    }>;
+};
+export type ConnectionSummaryFieldsFragment = {
+    __typename?: 'ChannelConnection';
+    id: string;
+    authType: Types.ChannelAuthType;
+    isActive: boolean;
+    isHealthy: boolean;
+    needsTokenRefresh: boolean;
+    lastTestedAt?: string | null;
+    testStatus?: string | null;
+    tagAssignments: Array<{
+        __typename?: 'ChannelConnectionTagAssignment';
+        id: string;
+        tagId: string;
+    }>;
+};
+export type ConnectionFieldsFragment = {
+    __typename?: 'ChannelConnection';
+    id: string;
+    channelId: string;
+    authType: Types.ChannelAuthType;
+    isActive: boolean;
+    platformMetadata?: Record<string, unknown> | null;
+    tokenExpiresAt?: string | null;
+    lastRefreshedAt?: string | null;
+    lastTestedAt?: string | null;
+    testStatus?: string | null;
+    needsTokenRefresh: boolean;
+    isHealthy: boolean;
+    daysUntilExpiry?: number | null;
+    createdAt: string;
+    updatedAt: string;
+    tagAssignments: Array<{
+        __typename?: 'ChannelConnectionTagAssignment';
+        id: string;
+        tagId: string;
+    }>;
+};
+export type DeliveryAttemptFieldsFragment = {
+    __typename?: 'MessageDeliveryAttempt';
+    id: string;
+    channelId: string;
+    content: string;
+    format?: string | null;
+    platformOptions?: Record<string, unknown> | null;
+    platformResponse?: Record<string, unknown> | null;
+    status: Types.DeliveryStatus;
+    retryCount: number;
+    nextRetryAt?: string | null;
+    sentAt?: string | null;
+    errorMessage?: string | null;
+    expiresAt: string;
+    createdAt: string;
+    updatedAt: string;
+};
+export type UserPlatformConnectionFieldsFragment = {
+    __typename?: 'UserPlatformConnection';
+    id: string;
+    channelId: string;
+    platform: Types.ChannelPlatform;
+    externalUserId: string;
+    externalUsername?: string | null;
+    externalDisplayName?: string | null;
+    externalEmail?: string | null;
+    externalAvatarUrl?: string | null;
+    externalMetadata?: Record<string, unknown> | null;
+    internalUserId?: string | null;
+    organizationId: string;
+    source: Types.UserPlatformSource;
+    connectedAt?: string | null;
+    dmAllowed: boolean;
+    dmConversationId?: string | null;
+    notificationsEnabled: boolean;
+    userTokenExpiresAt?: string | null;
+    userTokenScope?: string | null;
+    pairingCode?: string | null;
+    pairingCodeExpiresAt?: string | null;
+    pairingStatus?: Types.PairingStatus | null;
+    pairingApprovedAt?: string | null;
+    presenceStatus: Types.UserPresenceStatus;
+    customStatus?: string | null;
+    lastActiveAt?: string | null;
+    isActive: boolean;
+    roles: Array<string>;
+    permissions: Array<string>;
+    lastSyncedAt: string;
+    deletedAt?: string | null;
+    createdAt: string;
+    updatedAt: string;
+    isTokenExpired: boolean;
+    canReceiveDm: boolean;
+};
+export type WebhookEventFieldsFragment = {
+    __typename?: 'WebhookEvent';
+    id: string;
+    channelId: string;
+    eventType: string;
+    status: Types.WebhookProcessingStatus;
+    payload: Record<string, unknown>;
+    signature?: string | null;
+    isDuplicate: boolean;
+    originalEventId?: string | null;
+    errorMessage?: string | null;
+    processingResult?: Record<string, unknown> | null;
+    processedAt?: string | null;
+    expiresAt: string;
+    createdAt: string;
+    updatedAt: string;
+    context?: {
+        __typename?: 'OperationContext';
+        tenantId?: string | null;
+        userId?: string | null;
+        appId?: string | null;
+        workspaceId?: string | null;
+        projectId?: string | null;
+        organizationId?: string | null;
+        custom?: Record<string, unknown> | null;
+    } | null;
+};
+export type ActivateChannelMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type ActivateChannelMutation = {
+    __typename?: 'Mutation';
+    activateChannel: {
+        __typename?: 'Channel';
+        id: string;
+        status: Types.ChannelStatus;
+    };
+};
+export type CreateChannelMutationVariables = Types.Exact<{
+    input: Types.CreateChannelInput;
+}>;
+export type CreateChannelMutation = {
+    __typename?: 'Mutation';
+    createChannel: {
+        __typename?: 'Channel';
+        id: string;
+        name: string;
+        description?: string | null;
+        platform: Types.ChannelPlatform;
+        adapterType?: Types.AdapterType | null;
+        status: Types.ChannelStatus;
+        priority: number;
+        connectionHealth: Types.ConnectionHealth;
+        lastHealthCheckAt?: string | null;
+        healthCheckError?: string | null;
+        consecutiveFailures: number;
+        organizationId: string;
+        createdBy: string;
+        onBehalfOf: string;
+        platformConfig?: Record<string, unknown> | null;
+        isConnected: boolean;
+        messageCount24h: number;
+        createdAt: string;
+        updatedAt: string;
+        tagAssignments: Array<{
+            __typename?: 'ChannelTagAssignment';
+            id: string;
+            tagId: string;
+        }>;
+    };
+};
+export type CreateConnectionMutationVariables = Types.Exact<{
+    input: Types.CreateConnectionInput;
+}>;
+export type CreateConnectionMutation = {
+    __typename?: 'Mutation';
+    createConnection: {
+        __typename?: 'ChannelConnection';
+        id: string;
+        channelId: string;
+        authType: Types.ChannelAuthType;
+        isActive: boolean;
+        platformMetadata?: Record<string, unknown> | null;
+        tokenExpiresAt?: string | null;
+        lastRefreshedAt?: string | null;
+        lastTestedAt?: string | null;
+        testStatus?: string | null;
+        needsTokenRefresh: boolean;
+        isHealthy: boolean;
+        daysUntilExpiry?: number | null;
+        createdAt: string;
+        updatedAt: string;
+        tagAssignments: Array<{
+            __typename?: 'ChannelConnectionTagAssignment';
+            id: string;
+            tagId: string;
+        }>;
+    };
+};
+export type DeactivateChannelMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type DeactivateChannelMutation = {
+    __typename?: 'Mutation';
+    deactivateChannel: {
+        __typename?: 'Channel';
+        id: string;
+        status: Types.ChannelStatus;
+    };
+};
+export type DeleteChannelMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type DeleteChannelMutation = {
+    __typename?: 'Mutation';
+    deleteChannel: boolean;
+};
+export type DeleteConnectionMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type DeleteConnectionMutation = {
+    __typename?: 'Mutation';
+    deleteConnection: boolean;
+};
+export type DeliverBulkNotificationMutationVariables = Types.Exact<{
+    input: Types.BulkChannelDeliveryInput;
+}>;
+export type DeliverBulkNotificationMutation = {
+    __typename?: 'Mutation';
+    deliverBulkNotification: {
+        __typename?: 'BulkChannelDeliveryResult';
+        totalCount: number;
+        successCount: number;
+        failedCount: number;
+        results: Array<{
+            __typename?: 'ChannelDeliveryResult';
+            success: boolean;
+            messageId?: string | null;
+            externalId?: string | null;
+            status: Types.DeliveryStatus;
+            platform: Types.ChannelPlatform;
+            sentAt?: string | null;
+            metadata?: Record<string, unknown> | null;
+            error?: {
+                __typename?: 'ChannelDeliveryError';
+                code: string;
+                message: string;
+                retryable: boolean;
+            } | null;
+        }>;
+    };
+};
+export type DeliverNotificationMutationVariables = Types.Exact<{
+    input: Types.ChannelDeliveryInput;
+}>;
+export type DeliverNotificationMutation = {
+    __typename?: 'Mutation';
+    deliverNotification: {
+        __typename?: 'ChannelDeliveryResult';
+        success: boolean;
+        messageId?: string | null;
+        externalId?: string | null;
+        status: Types.DeliveryStatus;
+        platform: Types.ChannelPlatform;
+        sentAt?: string | null;
+        metadata?: Record<string, unknown> | null;
+        error?: {
+            __typename?: 'ChannelDeliveryError';
+            code: string;
+            message: string;
+            retryable: boolean;
+            details?: Record<string, unknown> | null;
+        } | null;
+    };
+};
+export type ExportChannelUsersMutationVariables = Types.Exact<{
+    filter: Types.ExportChannelUsersFilter;
+    format: Types.ChannelExportFormat;
+}>;
+export type ExportChannelUsersMutation = {
+    __typename?: 'Mutation';
+    exportChannelUsers: {
+        __typename?: 'ChannelExportJob';
+        id: string;
+        status: Types.ChannelExportStatus;
+        entityType: string;
+        format: Types.ChannelExportFormat;
+        rowCount?: number | null;
+        downloadUrl?: string | null;
+        error?: string | null;
+    };
+};
+export type ExportChannelsMutationVariables = Types.Exact<{
+    filter: Types.ExportChannelsFilter;
+    format: Types.ChannelExportFormat;
+}>;
+export type ExportChannelsMutation = {
+    __typename?: 'Mutation';
+    exportChannels: {
+        __typename?: 'ChannelExportJob';
+        id: string;
+        status: Types.ChannelExportStatus;
+        entityType: string;
+        format: Types.ChannelExportFormat;
+        rowCount?: number | null;
+        downloadUrl?: string | null;
+        error?: string | null;
+    };
+};
+export type ExportDeliveryAttemptsMutationVariables = Types.Exact<{
+    filter: Types.ExportDeliveryAttemptsFilter;
+    format: Types.ChannelExportFormat;
+}>;
+export type ExportDeliveryAttemptsMutation = {
+    __typename?: 'Mutation';
+    exportDeliveryAttempts: {
+        __typename?: 'ChannelExportJob';
+        id: string;
+        status: Types.ChannelExportStatus;
+        entityType: string;
+        format: Types.ChannelExportFormat;
+        rowCount?: number | null;
+        downloadUrl?: string | null;
+        error?: string | null;
+    };
+};
+export type ExportWebhookEventsMutationVariables = Types.Exact<{
+    filter: Types.ExportWebhookEventsFilter;
+    format: Types.ChannelExportFormat;
+}>;
+export type ExportWebhookEventsMutation = {
+    __typename?: 'Mutation';
+    exportWebhookEvents: {
+        __typename?: 'ChannelExportJob';
+        id: string;
+        status: Types.ChannelExportStatus;
+        entityType: string;
+        format: Types.ChannelExportFormat;
+        rowCount?: number | null;
+        downloadUrl?: string | null;
+        error?: string | null;
+    };
+};
+export type RetryDeliveryMutationVariables = Types.Exact<{
+    attemptId: Types.Scalars['ID']['input'];
+}>;
+export type RetryDeliveryMutation = {
+    __typename?: 'Mutation';
+    retryDelivery: {
+        __typename?: 'MessageDeliveryResult';
+        success: boolean;
+        messageId?: string | null;
+        attemptId: string;
+        error?: string | null;
+        willRetry: boolean;
+        nextRetryAt?: string | null;
+    };
+};
+export type RunChannelHealthCheckMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type RunChannelHealthCheckMutation = {
+    __typename?: 'Mutation';
+    runChannelHealthCheck: {
+        __typename?: 'ChannelHealthCheck';
+        channelId: string;
+        isHealthy: boolean;
+        status: string;
+        responseTimeMs?: number | null;
+        lastCheckAt: string;
+        error?: string | null;
+    };
+};
+export type TestConnectionHealthMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type TestConnectionHealthMutation = {
+    __typename?: 'Mutation';
+    testConnectionHealth: {
+        __typename?: 'ConnectionTestResult';
+        success: boolean;
+        message: string;
+        responseTimeMs?: number | null;
+        platformInfo?: Record<string, unknown> | null;
+        error?: string | null;
+    };
+};
+export type UpdateChannelMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+    input: Types.UpdateChannelInput;
+}>;
+export type UpdateChannelMutation = {
+    __typename?: 'Mutation';
+    updateChannel: {
+        __typename?: 'Channel';
+        id: string;
+        name: string;
+        description?: string | null;
+        platform: Types.ChannelPlatform;
+        adapterType?: Types.AdapterType | null;
+        status: Types.ChannelStatus;
+        priority: number;
+        connectionHealth: Types.ConnectionHealth;
+        lastHealthCheckAt?: string | null;
+        healthCheckError?: string | null;
+        consecutiveFailures: number;
+        organizationId: string;
+        createdBy: string;
+        onBehalfOf: string;
+        platformConfig?: Record<string, unknown> | null;
+        isConnected: boolean;
+        messageCount24h: number;
+        createdAt: string;
+        updatedAt: string;
+        tagAssignments: Array<{
+            __typename?: 'ChannelTagAssignment';
+            id: string;
+            tagId: string;
+        }>;
+    };
+};
+export type UpdateChannelOrgSettingsMutationVariables = Types.Exact<{
+    organizationId: Types.Scalars['ID']['input'];
+    input: Types.ChannelOrgSettingsInput;
+}>;
+export type UpdateChannelOrgSettingsMutation = {
+    __typename?: 'Mutation';
+    updateChannelOrgSettings: {
+        __typename?: 'ChannelOrgSettings';
+        organizationId: string;
+        defaultPriority: number;
+        rateLimitPerMinute: number;
+        rateLimitPerHour: number;
+        healthCheckIntervalMinutes: number;
+        enableAuditLogging: boolean;
+        enableWebhookVerification: boolean;
+        sessionTimeoutMinutes: number;
+        updatedAt: string;
+    };
+};
+export type UpdateConnectionMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+    input: Types.UpdateConnectionInput;
+}>;
+export type UpdateConnectionMutation = {
+    __typename?: 'Mutation';
+    updateConnection: {
+        __typename?: 'ChannelConnection';
+        id: string;
+        channelId: string;
+        authType: Types.ChannelAuthType;
+        isActive: boolean;
+        platformMetadata?: Record<string, unknown> | null;
+        tokenExpiresAt?: string | null;
+        lastRefreshedAt?: string | null;
+        lastTestedAt?: string | null;
+        testStatus?: string | null;
+        needsTokenRefresh: boolean;
+        isHealthy: boolean;
+        daysUntilExpiry?: number | null;
+        createdAt: string;
+        updatedAt: string;
+        tagAssignments: Array<{
+            __typename?: 'ChannelConnectionTagAssignment';
+            id: string;
+            tagId: string;
+        }>;
+    };
+};
+export type GetChannelQueryVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type GetChannelQuery = {
+    __typename?: 'Query';
+    getChannel?: {
+        __typename?: 'Channel';
+        id: string;
+        name: string;
+        description?: string | null;
+        platform: Types.ChannelPlatform;
+        adapterType?: Types.AdapterType | null;
+        status: Types.ChannelStatus;
+        priority: number;
+        connectionHealth: Types.ConnectionHealth;
+        lastHealthCheckAt?: string | null;
+        healthCheckError?: string | null;
+        consecutiveFailures: number;
+        organizationId: string;
+        createdBy: string;
+        onBehalfOf: string;
+        platformConfig?: Record<string, unknown> | null;
+        isConnected: boolean;
+        messageCount24h: number;
+        createdAt: string;
+        updatedAt: string;
+        connection?: {
+            __typename?: 'ChannelConnection';
+            id: string;
+            channelId: string;
+            authType: Types.ChannelAuthType;
+            isActive: boolean;
+            platformMetadata?: Record<string, unknown> | null;
+            tokenExpiresAt?: string | null;
+            lastRefreshedAt?: string | null;
+            lastTestedAt?: string | null;
+            testStatus?: string | null;
+            needsTokenRefresh: boolean;
+            isHealthy: boolean;
+            daysUntilExpiry?: number | null;
+            createdAt: string;
+            updatedAt: string;
+            tagAssignments: Array<{
+                __typename?: 'ChannelConnectionTagAssignment';
+                id: string;
+                tagId: string;
+            }>;
+        } | null;
+        tagAssignments: Array<{
+            __typename?: 'ChannelTagAssignment';
+            id: string;
+            tagId: string;
+        }>;
+    } | null;
+};
+export type GetChannelExportJobQueryVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type GetChannelExportJobQuery = {
+    __typename?: 'Query';
+    channelExportJob?: {
+        __typename?: 'ChannelExportJob';
+        id: string;
+        status: Types.ChannelExportStatus;
+        entityType: string;
+        format: Types.ChannelExportFormat;
+        rowCount?: number | null;
+        downloadUrl?: string | null;
+        error?: string | null;
+    } | null;
+};
+export type GetChannelOrgSettingsQueryVariables = Types.Exact<{
+    organizationId: Types.Scalars['ID']['input'];
+}>;
+export type GetChannelOrgSettingsQuery = {
+    __typename?: 'Query';
+    getChannelOrgSettings: {
+        __typename?: 'ChannelOrgSettings';
+        organizationId: string;
+        defaultPriority: number;
+        rateLimitPerMinute: number;
+        rateLimitPerHour: number;
+        healthCheckIntervalMinutes: number;
+        enableAuditLogging: boolean;
+        enableWebhookVerification: boolean;
+        sessionTimeoutMinutes: number;
+        updatedAt: string;
+    };
+};
+export type GetChannelsQueryVariables = Types.Exact<{
+    filter?: Types.InputMaybe<Types.ChannelFilterInput>;
+    pagination?: Types.InputMaybe<Types.ChannelPaginationInput>;
+}>;
+export type GetChannelsQuery = {
+    __typename?: 'Query';
+    getChannels: {
+        __typename?: 'ChannelList';
+        total: number;
+        hasMore: boolean;
+        items: Array<{
+            __typename?: 'Channel';
+            id: string;
+            name: string;
+            description?: string | null;
+            platform: Types.ChannelPlatform;
+            adapterType?: Types.AdapterType | null;
+            status: Types.ChannelStatus;
+            priority: number;
+            connectionHealth: Types.ConnectionHealth;
+            lastHealthCheckAt?: string | null;
+            healthCheckError?: string | null;
+            consecutiveFailures: number;
+            organizationId: string;
+            createdBy: string;
+            onBehalfOf: string;
+            platformConfig?: Record<string, unknown> | null;
+            isConnected: boolean;
+            messageCount24h: number;
+            createdAt: string;
+            updatedAt: string;
+            connection?: {
+                __typename?: 'ChannelConnection';
+                id: string;
+                authType: Types.ChannelAuthType;
+                isActive: boolean;
+                isHealthy: boolean;
+                needsTokenRefresh: boolean;
+                lastTestedAt?: string | null;
+                testStatus?: string | null;
+                tagAssignments: Array<{
+                    __typename?: 'ChannelConnectionTagAssignment';
+                    id: string;
+                    tagId: string;
+                }>;
+            } | null;
+            tagAssignments: Array<{
+                __typename?: 'ChannelTagAssignment';
+                id: string;
+                tagId: string;
+            }>;
+        }>;
+    };
+};
+export type GetConnectionQueryVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type GetConnectionQuery = {
+    __typename?: 'Query';
+    getConnection?: {
+        __typename?: 'ChannelConnection';
+        id: string;
+        channelId: string;
+        authType: Types.ChannelAuthType;
+        isActive: boolean;
+        platformMetadata?: Record<string, unknown> | null;
+        tokenExpiresAt?: string | null;
+        lastRefreshedAt?: string | null;
+        lastTestedAt?: string | null;
+        testStatus?: string | null;
+        needsTokenRefresh: boolean;
+        isHealthy: boolean;
+        daysUntilExpiry?: number | null;
+        createdAt: string;
+        updatedAt: string;
+        tagAssignments: Array<{
+            __typename?: 'ChannelConnectionTagAssignment';
+            id: string;
+            tagId: string;
+        }>;
+    } | null;
+};
+export type GetDeliveryAttemptsQueryVariables = Types.Exact<{
+    channelId: Types.Scalars['ID']['input'];
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    cursor?: Types.InputMaybe<Types.Scalars['String']['input']>;
+}>;
+export type GetDeliveryAttemptsQuery = {
+    __typename?: 'Query';
+    getChannelDeliveryAttempts: {
+        __typename?: 'DeliveryAttemptList';
+        nextCursor?: string | null;
+        hasMore: boolean;
+        total: number;
+        items: Array<{
+            __typename?: 'MessageDeliveryAttempt';
+            id: string;
+            channelId: string;
+            content: string;
+            format?: string | null;
+            platformOptions?: Record<string, unknown> | null;
+            platformResponse?: Record<string, unknown> | null;
+            status: Types.DeliveryStatus;
+            retryCount: number;
+            nextRetryAt?: string | null;
+            sentAt?: string | null;
+            errorMessage?: string | null;
+            expiresAt: string;
+            createdAt: string;
+            updatedAt: string;
+        }>;
+    };
+};
+export type GetDeliveryStatsQueryVariables = Types.Exact<{
+    channelId: Types.Scalars['ID']['input'];
+    startDate?: Types.InputMaybe<Types.Scalars['DateTime']['input']>;
+    endDate?: Types.InputMaybe<Types.Scalars['DateTime']['input']>;
+}>;
+export type GetDeliveryStatsQuery = {
+    __typename?: 'Query';
+    getDeliveryStats: {
+        __typename?: 'DeliveryStats';
+        channelId: string;
+        totalAttempts: number;
+        successfulDeliveries: number;
+        failedDeliveries: number;
+        pendingDeliveries: number;
+        avgDeliveryTimeMs: number;
+        successRate: number;
+        startDate: string;
+        endDate: string;
+    };
+};
+export type GetUserPlatformConnectionsQueryVariables = Types.Exact<{
+    channelId: Types.Scalars['ID']['input'];
+    filter?: Types.InputMaybe<Types.UserPlatformConnectionFilterInput>;
+    pagination?: Types.InputMaybe<Types.ChannelPaginationInput>;
+    cursor?: Types.InputMaybe<Types.Scalars['String']['input']>;
+}>;
+export type GetUserPlatformConnectionsQuery = {
+    __typename?: 'Query';
+    listUserPlatformConnectionsByChannel: {
+        __typename?: 'UserPlatformConnectionList';
+        nextCursor?: string | null;
+        hasMore: boolean;
+        total: number;
+        items: Array<{
+            __typename?: 'UserPlatformConnection';
+            id: string;
+            channelId: string;
+            platform: Types.ChannelPlatform;
+            externalUserId: string;
+            externalUsername?: string | null;
+            externalDisplayName?: string | null;
+            externalEmail?: string | null;
+            externalAvatarUrl?: string | null;
+            externalMetadata?: Record<string, unknown> | null;
+            internalUserId?: string | null;
+            organizationId: string;
+            source: Types.UserPlatformSource;
+            connectedAt?: string | null;
+            dmAllowed: boolean;
+            dmConversationId?: string | null;
+            notificationsEnabled: boolean;
+            userTokenExpiresAt?: string | null;
+            userTokenScope?: string | null;
+            pairingCode?: string | null;
+            pairingCodeExpiresAt?: string | null;
+            pairingStatus?: Types.PairingStatus | null;
+            pairingApprovedAt?: string | null;
+            presenceStatus: Types.UserPresenceStatus;
+            customStatus?: string | null;
+            lastActiveAt?: string | null;
+            isActive: boolean;
+            roles: Array<string>;
+            permissions: Array<string>;
+            lastSyncedAt: string;
+            deletedAt?: string | null;
+            createdAt: string;
+            updatedAt: string;
+            isTokenExpired: boolean;
+            canReceiveDm: boolean;
+        }>;
+    };
+};
+export type GetWebhookEventsQueryVariables = Types.Exact<{
+    channelId: Types.Scalars['ID']['input'];
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    cursor?: Types.InputMaybe<Types.Scalars['String']['input']>;
+}>;
+export type GetWebhookEventsQuery = {
+    __typename?: 'Query';
+    getChannelWebhookEvents: {
+        __typename?: 'WebhookEventList';
+        nextCursor?: string | null;
+        hasMore: boolean;
+        total: number;
+        items: Array<{
+            __typename?: 'WebhookEvent';
+            id: string;
+            channelId: string;
+            eventType: string;
+            status: Types.WebhookProcessingStatus;
+            payload: Record<string, unknown>;
+            signature?: string | null;
+            isDuplicate: boolean;
+            originalEventId?: string | null;
+            errorMessage?: string | null;
+            processingResult?: Record<string, unknown> | null;
+            processedAt?: string | null;
+            expiresAt: string;
+            createdAt: string;
+            updatedAt: string;
+            context?: {
+                __typename?: 'OperationContext';
+                tenantId?: string | null;
+                userId?: string | null;
+                appId?: string | null;
+                workspaceId?: string | null;
+                projectId?: string | null;
+                organizationId?: string | null;
+                custom?: Record<string, unknown> | null;
+            } | null;
+        }>;
+    };
+};
+export type SendNotificationMutationVariables = Types.Exact<{
+    input: Types.TriggerNotificationInput;
+}>;
+export type SendNotificationMutation = {
+    __typename?: 'Mutation';
+    triggerNotification: {
+        __typename?: 'Notification';
+        id: string;
+        status: Types.NotificationStatus;
+        deliveryStatus?: Types.NotificationDeliveryStatus | null;
+        triggerStatus: Types.TriggerStatus;
+        sentAt?: string | null;
+        title: string;
+        message: string;
+    };
+};
+export declare const ChannelFieldsFragmentDoc: Apollo.DocumentNode;
+export declare const ConnectionSummaryFieldsFragmentDoc: Apollo.DocumentNode;
+export declare const ConnectionFieldsFragmentDoc: Apollo.DocumentNode;
+export declare const DeliveryAttemptFieldsFragmentDoc: Apollo.DocumentNode;
+export declare const UserPlatformConnectionFieldsFragmentDoc: Apollo.DocumentNode;
+export declare const WebhookEventFieldsFragmentDoc: Apollo.DocumentNode;
+export declare const ActivateChannelDocument: Apollo.DocumentNode;
+export type ActivateChannelMutationFn = Apollo.MutationFunction<Types.ActivateChannelMutation, Types.ActivateChannelMutationVariables>;
+/**
+ * __useActivateChannelMutation__
+ *
+ * To run a mutation, you first call `useActivateChannelMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useActivateChannelMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [activateChannelMutation, { data, loading, error }] = useActivateChannelMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useActivateChannelMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ActivateChannelMutation, Types.ActivateChannelMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ActivateChannelMutation, any, Apollo.ApolloCache>;
+export type ActivateChannelMutationHookResult = ReturnType<typeof useActivateChannelMutation>;
+export type ActivateChannelMutationResult = Apollo.MutationResult<Types.ActivateChannelMutation>;
+export type ActivateChannelMutationOptions = Apollo.BaseMutationOptions<Types.ActivateChannelMutation, Types.ActivateChannelMutationVariables>;
+export declare const CreateChannelDocument: Apollo.DocumentNode;
+export type CreateChannelMutationFn = Apollo.MutationFunction<Types.CreateChannelMutation, Types.CreateChannelMutationVariables>;
+/**
+ * __useCreateChannelMutation__
+ *
+ * To run a mutation, you first call `useCreateChannelMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateChannelMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [createChannelMutation, { data, loading, error }] = useCreateChannelMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useCreateChannelMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateChannelMutation, Types.CreateChannelMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateChannelMutation, any, Apollo.ApolloCache>;
+export type CreateChannelMutationHookResult = ReturnType<typeof useCreateChannelMutation>;
+export type CreateChannelMutationResult = Apollo.MutationResult<Types.CreateChannelMutation>;
+export type CreateChannelMutationOptions = Apollo.BaseMutationOptions<Types.CreateChannelMutation, Types.CreateChannelMutationVariables>;
+export declare const CreateConnectionDocument: Apollo.DocumentNode;
+export type CreateConnectionMutationFn = Apollo.MutationFunction<Types.CreateConnectionMutation, Types.CreateConnectionMutationVariables>;
+/**
+ * __useCreateConnectionMutation__
+ *
+ * To run a mutation, you first call `useCreateConnectionMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateConnectionMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [createConnectionMutation, { data, loading, error }] = useCreateConnectionMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useCreateConnectionMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateConnectionMutation, Types.CreateConnectionMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateConnectionMutation, any, Apollo.ApolloCache>;
+export type CreateConnectionMutationHookResult = ReturnType<typeof useCreateConnectionMutation>;
+export type CreateConnectionMutationResult = Apollo.MutationResult<Types.CreateConnectionMutation>;
+export type CreateConnectionMutationOptions = Apollo.BaseMutationOptions<Types.CreateConnectionMutation, Types.CreateConnectionMutationVariables>;
+export declare const DeactivateChannelDocument: Apollo.DocumentNode;
+export type DeactivateChannelMutationFn = Apollo.MutationFunction<Types.DeactivateChannelMutation, Types.DeactivateChannelMutationVariables>;
+/**
+ * __useDeactivateChannelMutation__
+ *
+ * To run a mutation, you first call `useDeactivateChannelMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeactivateChannelMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [deactivateChannelMutation, { data, loading, error }] = useDeactivateChannelMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useDeactivateChannelMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeactivateChannelMutation, Types.DeactivateChannelMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeactivateChannelMutation, any, Apollo.ApolloCache>;
+export type DeactivateChannelMutationHookResult = ReturnType<typeof useDeactivateChannelMutation>;
+export type DeactivateChannelMutationResult = Apollo.MutationResult<Types.DeactivateChannelMutation>;
+export type DeactivateChannelMutationOptions = Apollo.BaseMutationOptions<Types.DeactivateChannelMutation, Types.DeactivateChannelMutationVariables>;
+export declare const DeleteChannelDocument: Apollo.DocumentNode;
+export type DeleteChannelMutationFn = Apollo.MutationFunction<Types.DeleteChannelMutation, Types.DeleteChannelMutationVariables>;
+/**
+ * __useDeleteChannelMutation__
+ *
+ * To run a mutation, you first call `useDeleteChannelMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteChannelMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [deleteChannelMutation, { data, loading, error }] = useDeleteChannelMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useDeleteChannelMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteChannelMutation, Types.DeleteChannelMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteChannelMutation, any, Apollo.ApolloCache>;
+export type DeleteChannelMutationHookResult = ReturnType<typeof useDeleteChannelMutation>;
+export type DeleteChannelMutationResult = Apollo.MutationResult<Types.DeleteChannelMutation>;
+export type DeleteChannelMutationOptions = Apollo.BaseMutationOptions<Types.DeleteChannelMutation, Types.DeleteChannelMutationVariables>;
+export declare const DeleteConnectionDocument: Apollo.DocumentNode;
+export type DeleteConnectionMutationFn = Apollo.MutationFunction<Types.DeleteConnectionMutation, Types.DeleteConnectionMutationVariables>;
+/**
+ * __useDeleteConnectionMutation__
+ *
+ * To run a mutation, you first call `useDeleteConnectionMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteConnectionMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [deleteConnectionMutation, { data, loading, error }] = useDeleteConnectionMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useDeleteConnectionMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteConnectionMutation, Types.DeleteConnectionMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteConnectionMutation, any, Apollo.ApolloCache>;
+export type DeleteConnectionMutationHookResult = ReturnType<typeof useDeleteConnectionMutation>;
+export type DeleteConnectionMutationResult = Apollo.MutationResult<Types.DeleteConnectionMutation>;
+export type DeleteConnectionMutationOptions = Apollo.BaseMutationOptions<Types.DeleteConnectionMutation, Types.DeleteConnectionMutationVariables>;
+export declare const DeliverBulkNotificationDocument: Apollo.DocumentNode;
+export type DeliverBulkNotificationMutationFn = Apollo.MutationFunction<Types.DeliverBulkNotificationMutation, Types.DeliverBulkNotificationMutationVariables>;
+/**
+ * __useDeliverBulkNotificationMutation__
+ *
+ * To run a mutation, you first call `useDeliverBulkNotificationMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeliverBulkNotificationMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [deliverBulkNotificationMutation, { data, loading, error }] = useDeliverBulkNotificationMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useDeliverBulkNotificationMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeliverBulkNotificationMutation, Types.DeliverBulkNotificationMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeliverBulkNotificationMutation, any, Apollo.ApolloCache>;
+export type DeliverBulkNotificationMutationHookResult = ReturnType<typeof useDeliverBulkNotificationMutation>;
+export type DeliverBulkNotificationMutationResult = Apollo.MutationResult<Types.DeliverBulkNotificationMutation>;
+export type DeliverBulkNotificationMutationOptions = Apollo.BaseMutationOptions<Types.DeliverBulkNotificationMutation, Types.DeliverBulkNotificationMutationVariables>;
+export declare const DeliverNotificationDocument: Apollo.DocumentNode;
+export type DeliverNotificationMutationFn = Apollo.MutationFunction<Types.DeliverNotificationMutation, Types.DeliverNotificationMutationVariables>;
+/**
+ * __useDeliverNotificationMutation__
+ *
+ * To run a mutation, you first call `useDeliverNotificationMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeliverNotificationMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [deliverNotificationMutation, { data, loading, error }] = useDeliverNotificationMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useDeliverNotificationMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeliverNotificationMutation, Types.DeliverNotificationMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeliverNotificationMutation, any, Apollo.ApolloCache>;
+export type DeliverNotificationMutationHookResult = ReturnType<typeof useDeliverNotificationMutation>;
+export type DeliverNotificationMutationResult = Apollo.MutationResult<Types.DeliverNotificationMutation>;
+export type DeliverNotificationMutationOptions = Apollo.BaseMutationOptions<Types.DeliverNotificationMutation, Types.DeliverNotificationMutationVariables>;
+export declare const ExportChannelUsersDocument: Apollo.DocumentNode;
+export type ExportChannelUsersMutationFn = Apollo.MutationFunction<Types.ExportChannelUsersMutation, Types.ExportChannelUsersMutationVariables>;
+/**
+ * __useExportChannelUsersMutation__
+ *
+ * To run a mutation, you first call `useExportChannelUsersMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useExportChannelUsersMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [exportChannelUsersMutation, { data, loading, error }] = useExportChannelUsersMutation({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      format: // value for 'format'
+ *   },
+ * });
+ */
+export declare function useExportChannelUsersMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ExportChannelUsersMutation, Types.ExportChannelUsersMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ExportChannelUsersMutation, any, Apollo.ApolloCache>;
+export type ExportChannelUsersMutationHookResult = ReturnType<typeof useExportChannelUsersMutation>;
+export type ExportChannelUsersMutationResult = Apollo.MutationResult<Types.ExportChannelUsersMutation>;
+export type ExportChannelUsersMutationOptions = Apollo.BaseMutationOptions<Types.ExportChannelUsersMutation, Types.ExportChannelUsersMutationVariables>;
+export declare const ExportChannelsDocument: Apollo.DocumentNode;
+export type ExportChannelsMutationFn = Apollo.MutationFunction<Types.ExportChannelsMutation, Types.ExportChannelsMutationVariables>;
+/**
+ * __useExportChannelsMutation__
+ *
+ * To run a mutation, you first call `useExportChannelsMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useExportChannelsMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [exportChannelsMutation, { data, loading, error }] = useExportChannelsMutation({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      format: // value for 'format'
+ *   },
+ * });
+ */
+export declare function useExportChannelsMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ExportChannelsMutation, Types.ExportChannelsMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ExportChannelsMutation, any, Apollo.ApolloCache>;
+export type ExportChannelsMutationHookResult = ReturnType<typeof useExportChannelsMutation>;
+export type ExportChannelsMutationResult = Apollo.MutationResult<Types.ExportChannelsMutation>;
+export type ExportChannelsMutationOptions = Apollo.BaseMutationOptions<Types.ExportChannelsMutation, Types.ExportChannelsMutationVariables>;
+export declare const ExportDeliveryAttemptsDocument: Apollo.DocumentNode;
+export type ExportDeliveryAttemptsMutationFn = Apollo.MutationFunction<Types.ExportDeliveryAttemptsMutation, Types.ExportDeliveryAttemptsMutationVariables>;
+/**
+ * __useExportDeliveryAttemptsMutation__
+ *
+ * To run a mutation, you first call `useExportDeliveryAttemptsMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useExportDeliveryAttemptsMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [exportDeliveryAttemptsMutation, { data, loading, error }] = useExportDeliveryAttemptsMutation({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      format: // value for 'format'
+ *   },
+ * });
+ */
+export declare function useExportDeliveryAttemptsMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ExportDeliveryAttemptsMutation, Types.ExportDeliveryAttemptsMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ExportDeliveryAttemptsMutation, any, Apollo.ApolloCache>;
+export type ExportDeliveryAttemptsMutationHookResult = ReturnType<typeof useExportDeliveryAttemptsMutation>;
+export type ExportDeliveryAttemptsMutationResult = Apollo.MutationResult<Types.ExportDeliveryAttemptsMutation>;
+export type ExportDeliveryAttemptsMutationOptions = Apollo.BaseMutationOptions<Types.ExportDeliveryAttemptsMutation, Types.ExportDeliveryAttemptsMutationVariables>;
+export declare const ExportWebhookEventsDocument: Apollo.DocumentNode;
+export type ExportWebhookEventsMutationFn = Apollo.MutationFunction<Types.ExportWebhookEventsMutation, Types.ExportWebhookEventsMutationVariables>;
+/**
+ * __useExportWebhookEventsMutation__
+ *
+ * To run a mutation, you first call `useExportWebhookEventsMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useExportWebhookEventsMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [exportWebhookEventsMutation, { data, loading, error }] = useExportWebhookEventsMutation({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      format: // value for 'format'
+ *   },
+ * });
+ */
+export declare function useExportWebhookEventsMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ExportWebhookEventsMutation, Types.ExportWebhookEventsMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ExportWebhookEventsMutation, any, Apollo.ApolloCache>;
+export type ExportWebhookEventsMutationHookResult = ReturnType<typeof useExportWebhookEventsMutation>;
+export type ExportWebhookEventsMutationResult = Apollo.MutationResult<Types.ExportWebhookEventsMutation>;
+export type ExportWebhookEventsMutationOptions = Apollo.BaseMutationOptions<Types.ExportWebhookEventsMutation, Types.ExportWebhookEventsMutationVariables>;
+export declare const RetryDeliveryDocument: Apollo.DocumentNode;
+export type RetryDeliveryMutationFn = Apollo.MutationFunction<Types.RetryDeliveryMutation, Types.RetryDeliveryMutationVariables>;
+/**
+ * __useRetryDeliveryMutation__
+ *
+ * To run a mutation, you first call `useRetryDeliveryMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRetryDeliveryMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [retryDeliveryMutation, { data, loading, error }] = useRetryDeliveryMutation({
+ *   variables: {
+ *      attemptId: // value for 'attemptId'
+ *   },
+ * });
+ */
+export declare function useRetryDeliveryMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RetryDeliveryMutation, Types.RetryDeliveryMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RetryDeliveryMutation, any, Apollo.ApolloCache>;
+export type RetryDeliveryMutationHookResult = ReturnType<typeof useRetryDeliveryMutation>;
+export type RetryDeliveryMutationResult = Apollo.MutationResult<Types.RetryDeliveryMutation>;
+export type RetryDeliveryMutationOptions = Apollo.BaseMutationOptions<Types.RetryDeliveryMutation, Types.RetryDeliveryMutationVariables>;
+export declare const RunChannelHealthCheckDocument: Apollo.DocumentNode;
+export type RunChannelHealthCheckMutationFn = Apollo.MutationFunction<Types.RunChannelHealthCheckMutation, Types.RunChannelHealthCheckMutationVariables>;
+/**
+ * __useRunChannelHealthCheckMutation__
+ *
+ * To run a mutation, you first call `useRunChannelHealthCheckMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRunChannelHealthCheckMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [runChannelHealthCheckMutation, { data, loading, error }] = useRunChannelHealthCheckMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useRunChannelHealthCheckMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RunChannelHealthCheckMutation, Types.RunChannelHealthCheckMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RunChannelHealthCheckMutation, any, Apollo.ApolloCache>;
+export type RunChannelHealthCheckMutationHookResult = ReturnType<typeof useRunChannelHealthCheckMutation>;
+export type RunChannelHealthCheckMutationResult = Apollo.MutationResult<Types.RunChannelHealthCheckMutation>;
+export type RunChannelHealthCheckMutationOptions = Apollo.BaseMutationOptions<Types.RunChannelHealthCheckMutation, Types.RunChannelHealthCheckMutationVariables>;
+export declare const TestConnectionHealthDocument: Apollo.DocumentNode;
+export type TestConnectionHealthMutationFn = Apollo.MutationFunction<Types.TestConnectionHealthMutation, Types.TestConnectionHealthMutationVariables>;
+/**
+ * __useTestConnectionHealthMutation__
+ *
+ * To run a mutation, you first call `useTestConnectionHealthMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useTestConnectionHealthMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [testConnectionHealthMutation, { data, loading, error }] = useTestConnectionHealthMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useTestConnectionHealthMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.TestConnectionHealthMutation, Types.TestConnectionHealthMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.TestConnectionHealthMutation, any, Apollo.ApolloCache>;
+export type TestConnectionHealthMutationHookResult = ReturnType<typeof useTestConnectionHealthMutation>;
+export type TestConnectionHealthMutationResult = Apollo.MutationResult<Types.TestConnectionHealthMutation>;
+export type TestConnectionHealthMutationOptions = Apollo.BaseMutationOptions<Types.TestConnectionHealthMutation, Types.TestConnectionHealthMutationVariables>;
+export declare const UpdateChannelDocument: Apollo.DocumentNode;
+export type UpdateChannelMutationFn = Apollo.MutationFunction<Types.UpdateChannelMutation, Types.UpdateChannelMutationVariables>;
+/**
+ * __useUpdateChannelMutation__
+ *
+ * To run a mutation, you first call `useUpdateChannelMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateChannelMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [updateChannelMutation, { data, loading, error }] = useUpdateChannelMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useUpdateChannelMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateChannelMutation, Types.UpdateChannelMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateChannelMutation, any, Apollo.ApolloCache>;
+export type UpdateChannelMutationHookResult = ReturnType<typeof useUpdateChannelMutation>;
+export type UpdateChannelMutationResult = Apollo.MutationResult<Types.UpdateChannelMutation>;
+export type UpdateChannelMutationOptions = Apollo.BaseMutationOptions<Types.UpdateChannelMutation, Types.UpdateChannelMutationVariables>;
+export declare const UpdateChannelOrgSettingsDocument: Apollo.DocumentNode;
+export type UpdateChannelOrgSettingsMutationFn = Apollo.MutationFunction<Types.UpdateChannelOrgSettingsMutation, Types.UpdateChannelOrgSettingsMutationVariables>;
+/**
+ * __useUpdateChannelOrgSettingsMutation__
+ *
+ * To run a mutation, you first call `useUpdateChannelOrgSettingsMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateChannelOrgSettingsMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [updateChannelOrgSettingsMutation, { data, loading, error }] = useUpdateChannelOrgSettingsMutation({
+ *   variables: {
+ *      organizationId: // value for 'organizationId'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useUpdateChannelOrgSettingsMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateChannelOrgSettingsMutation, Types.UpdateChannelOrgSettingsMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateChannelOrgSettingsMutation, any, Apollo.ApolloCache>;
+export type UpdateChannelOrgSettingsMutationHookResult = ReturnType<typeof useUpdateChannelOrgSettingsMutation>;
+export type UpdateChannelOrgSettingsMutationResult = Apollo.MutationResult<Types.UpdateChannelOrgSettingsMutation>;
+export type UpdateChannelOrgSettingsMutationOptions = Apollo.BaseMutationOptions<Types.UpdateChannelOrgSettingsMutation, Types.UpdateChannelOrgSettingsMutationVariables>;
+export declare const UpdateConnectionDocument: Apollo.DocumentNode;
+export type UpdateConnectionMutationFn = Apollo.MutationFunction<Types.UpdateConnectionMutation, Types.UpdateConnectionMutationVariables>;
+/**
+ * __useUpdateConnectionMutation__
+ *
+ * To run a mutation, you first call `useUpdateConnectionMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateConnectionMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [updateConnectionMutation, { data, loading, error }] = useUpdateConnectionMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useUpdateConnectionMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateConnectionMutation, Types.UpdateConnectionMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateConnectionMutation, any, Apollo.ApolloCache>;
+export type UpdateConnectionMutationHookResult = ReturnType<typeof useUpdateConnectionMutation>;
+export type UpdateConnectionMutationResult = Apollo.MutationResult<Types.UpdateConnectionMutation>;
+export type UpdateConnectionMutationOptions = Apollo.BaseMutationOptions<Types.UpdateConnectionMutation, Types.UpdateConnectionMutationVariables>;
+export declare const GetChannelDocument: Apollo.DocumentNode;
+/**
+ * __useGetChannelQuery__
+ *
+ * To run a query within a React component, call `useGetChannelQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetChannelQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetChannelQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useGetChannelQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetChannelQuery, Types.GetChannelQueryVariables> & ({
+    variables: Types.GetChannelQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetChannelQuery, Types.GetChannelQueryVariables, "empty" | "complete" | "streaming", Types.GetChannelQueryVariables>;
+export declare function useGetChannelLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetChannelQuery, Types.GetChannelQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetChannelQuery, Types.GetChannelQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetChannelSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetChannelQuery, Types.GetChannelQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetChannelQuery, Types.GetChannelQueryVariables>;
+export declare function useGetChannelSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetChannelQuery, Types.GetChannelQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetChannelQuery | undefined, Types.GetChannelQueryVariables>;
+export type GetChannelQueryHookResult = ReturnType<typeof useGetChannelQuery>;
+export type GetChannelLazyQueryHookResult = ReturnType<typeof useGetChannelLazyQuery>;
+export type GetChannelSuspenseQueryHookResult = ReturnType<typeof useGetChannelSuspenseQuery>;
+export type GetChannelQueryResult = Apollo.QueryResult<Types.GetChannelQuery, Types.GetChannelQueryVariables>;
+export declare const GetChannelExportJobDocument: Apollo.DocumentNode;
+/**
+ * __useGetChannelExportJobQuery__
+ *
+ * To run a query within a React component, call `useGetChannelExportJobQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetChannelExportJobQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetChannelExportJobQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useGetChannelExportJobQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetChannelExportJobQuery, Types.GetChannelExportJobQueryVariables> & ({
+    variables: Types.GetChannelExportJobQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetChannelExportJobQuery, Types.GetChannelExportJobQueryVariables, "empty" | "complete" | "streaming", Types.GetChannelExportJobQueryVariables>;
+export declare function useGetChannelExportJobLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetChannelExportJobQuery, Types.GetChannelExportJobQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetChannelExportJobQuery, Types.GetChannelExportJobQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetChannelExportJobSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetChannelExportJobQuery, Types.GetChannelExportJobQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetChannelExportJobQuery, Types.GetChannelExportJobQueryVariables>;
+export declare function useGetChannelExportJobSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetChannelExportJobQuery, Types.GetChannelExportJobQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetChannelExportJobQuery | undefined, Types.GetChannelExportJobQueryVariables>;
+export type GetChannelExportJobQueryHookResult = ReturnType<typeof useGetChannelExportJobQuery>;
+export type GetChannelExportJobLazyQueryHookResult = ReturnType<typeof useGetChannelExportJobLazyQuery>;
+export type GetChannelExportJobSuspenseQueryHookResult = ReturnType<typeof useGetChannelExportJobSuspenseQuery>;
+export type GetChannelExportJobQueryResult = Apollo.QueryResult<Types.GetChannelExportJobQuery, Types.GetChannelExportJobQueryVariables>;
+export declare const GetChannelOrgSettingsDocument: Apollo.DocumentNode;
+/**
+ * __useGetChannelOrgSettingsQuery__
+ *
+ * To run a query within a React component, call `useGetChannelOrgSettingsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetChannelOrgSettingsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetChannelOrgSettingsQuery({
+ *   variables: {
+ *      organizationId: // value for 'organizationId'
+ *   },
+ * });
+ */
+export declare function useGetChannelOrgSettingsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetChannelOrgSettingsQuery, Types.GetChannelOrgSettingsQueryVariables> & ({
+    variables: Types.GetChannelOrgSettingsQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetChannelOrgSettingsQuery, Types.GetChannelOrgSettingsQueryVariables, "empty" | "complete" | "streaming", Types.GetChannelOrgSettingsQueryVariables>;
+export declare function useGetChannelOrgSettingsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetChannelOrgSettingsQuery, Types.GetChannelOrgSettingsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetChannelOrgSettingsQuery, Types.GetChannelOrgSettingsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetChannelOrgSettingsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetChannelOrgSettingsQuery, Types.GetChannelOrgSettingsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetChannelOrgSettingsQuery, Types.GetChannelOrgSettingsQueryVariables>;
+export declare function useGetChannelOrgSettingsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetChannelOrgSettingsQuery, Types.GetChannelOrgSettingsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetChannelOrgSettingsQuery | undefined, Types.GetChannelOrgSettingsQueryVariables>;
+export type GetChannelOrgSettingsQueryHookResult = ReturnType<typeof useGetChannelOrgSettingsQuery>;
+export type GetChannelOrgSettingsLazyQueryHookResult = ReturnType<typeof useGetChannelOrgSettingsLazyQuery>;
+export type GetChannelOrgSettingsSuspenseQueryHookResult = ReturnType<typeof useGetChannelOrgSettingsSuspenseQuery>;
+export type GetChannelOrgSettingsQueryResult = Apollo.QueryResult<Types.GetChannelOrgSettingsQuery, Types.GetChannelOrgSettingsQueryVariables>;
+export declare const GetChannelsDocument: Apollo.DocumentNode;
+/**
+ * __useGetChannelsQuery__
+ *
+ * To run a query within a React component, call `useGetChannelsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetChannelsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetChannelsQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export declare function useGetChannelsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetChannelsQuery, Types.GetChannelsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetChannelsQuery, Types.GetChannelsQueryVariables, "empty" | "complete" | "streaming", Types.GetChannelsQueryVariables>;
+export declare function useGetChannelsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetChannelsQuery, Types.GetChannelsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetChannelsQuery, Types.GetChannelsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetChannelsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetChannelsQuery, Types.GetChannelsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetChannelsQuery, Types.GetChannelsQueryVariables>;
+export declare function useGetChannelsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetChannelsQuery, Types.GetChannelsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetChannelsQuery | undefined, Types.GetChannelsQueryVariables>;
+export type GetChannelsQueryHookResult = ReturnType<typeof useGetChannelsQuery>;
+export type GetChannelsLazyQueryHookResult = ReturnType<typeof useGetChannelsLazyQuery>;
+export type GetChannelsSuspenseQueryHookResult = ReturnType<typeof useGetChannelsSuspenseQuery>;
+export type GetChannelsQueryResult = Apollo.QueryResult<Types.GetChannelsQuery, Types.GetChannelsQueryVariables>;
+export declare const GetConnectionDocument: Apollo.DocumentNode;
+/**
+ * __useGetConnectionQuery__
+ *
+ * To run a query within a React component, call `useGetConnectionQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetConnectionQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetConnectionQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useGetConnectionQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetConnectionQuery, Types.GetConnectionQueryVariables> & ({
+    variables: Types.GetConnectionQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetConnectionQuery, Types.GetConnectionQueryVariables, "empty" | "complete" | "streaming", Types.GetConnectionQueryVariables>;
+export declare function useGetConnectionLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetConnectionQuery, Types.GetConnectionQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetConnectionQuery, Types.GetConnectionQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetConnectionSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetConnectionQuery, Types.GetConnectionQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetConnectionQuery, Types.GetConnectionQueryVariables>;
+export declare function useGetConnectionSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetConnectionQuery, Types.GetConnectionQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetConnectionQuery | undefined, Types.GetConnectionQueryVariables>;
+export type GetConnectionQueryHookResult = ReturnType<typeof useGetConnectionQuery>;
+export type GetConnectionLazyQueryHookResult = ReturnType<typeof useGetConnectionLazyQuery>;
+export type GetConnectionSuspenseQueryHookResult = ReturnType<typeof useGetConnectionSuspenseQuery>;
+export type GetConnectionQueryResult = Apollo.QueryResult<Types.GetConnectionQuery, Types.GetConnectionQueryVariables>;
+export declare const GetDeliveryAttemptsDocument: Apollo.DocumentNode;
+/**
+ * __useGetDeliveryAttemptsQuery__
+ *
+ * To run a query within a React component, call `useGetDeliveryAttemptsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetDeliveryAttemptsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetDeliveryAttemptsQuery({
+ *   variables: {
+ *      channelId: // value for 'channelId'
+ *      limit: // value for 'limit'
+ *      cursor: // value for 'cursor'
+ *   },
+ * });
+ */
+export declare function useGetDeliveryAttemptsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetDeliveryAttemptsQuery, Types.GetDeliveryAttemptsQueryVariables> & ({
+    variables: Types.GetDeliveryAttemptsQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetDeliveryAttemptsQuery, Types.GetDeliveryAttemptsQueryVariables, "empty" | "complete" | "streaming", Types.GetDeliveryAttemptsQueryVariables>;
+export declare function useGetDeliveryAttemptsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetDeliveryAttemptsQuery, Types.GetDeliveryAttemptsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetDeliveryAttemptsQuery, Types.GetDeliveryAttemptsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetDeliveryAttemptsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetDeliveryAttemptsQuery, Types.GetDeliveryAttemptsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetDeliveryAttemptsQuery, Types.GetDeliveryAttemptsQueryVariables>;
+export declare function useGetDeliveryAttemptsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetDeliveryAttemptsQuery, Types.GetDeliveryAttemptsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetDeliveryAttemptsQuery | undefined, Types.GetDeliveryAttemptsQueryVariables>;
+export type GetDeliveryAttemptsQueryHookResult = ReturnType<typeof useGetDeliveryAttemptsQuery>;
+export type GetDeliveryAttemptsLazyQueryHookResult = ReturnType<typeof useGetDeliveryAttemptsLazyQuery>;
+export type GetDeliveryAttemptsSuspenseQueryHookResult = ReturnType<typeof useGetDeliveryAttemptsSuspenseQuery>;
+export type GetDeliveryAttemptsQueryResult = Apollo.QueryResult<Types.GetDeliveryAttemptsQuery, Types.GetDeliveryAttemptsQueryVariables>;
+export declare const GetDeliveryStatsDocument: Apollo.DocumentNode;
+/**
+ * __useGetDeliveryStatsQuery__
+ *
+ * To run a query within a React component, call `useGetDeliveryStatsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetDeliveryStatsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetDeliveryStatsQuery({
+ *   variables: {
+ *      channelId: // value for 'channelId'
+ *      startDate: // value for 'startDate'
+ *      endDate: // value for 'endDate'
+ *   },
+ * });
+ */
+export declare function useGetDeliveryStatsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetDeliveryStatsQuery, Types.GetDeliveryStatsQueryVariables> & ({
+    variables: Types.GetDeliveryStatsQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetDeliveryStatsQuery, Types.GetDeliveryStatsQueryVariables, "empty" | "complete" | "streaming", Types.GetDeliveryStatsQueryVariables>;
+export declare function useGetDeliveryStatsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetDeliveryStatsQuery, Types.GetDeliveryStatsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetDeliveryStatsQuery, Types.GetDeliveryStatsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetDeliveryStatsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetDeliveryStatsQuery, Types.GetDeliveryStatsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetDeliveryStatsQuery, Types.GetDeliveryStatsQueryVariables>;
+export declare function useGetDeliveryStatsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetDeliveryStatsQuery, Types.GetDeliveryStatsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetDeliveryStatsQuery | undefined, Types.GetDeliveryStatsQueryVariables>;
+export type GetDeliveryStatsQueryHookResult = ReturnType<typeof useGetDeliveryStatsQuery>;
+export type GetDeliveryStatsLazyQueryHookResult = ReturnType<typeof useGetDeliveryStatsLazyQuery>;
+export type GetDeliveryStatsSuspenseQueryHookResult = ReturnType<typeof useGetDeliveryStatsSuspenseQuery>;
+export type GetDeliveryStatsQueryResult = Apollo.QueryResult<Types.GetDeliveryStatsQuery, Types.GetDeliveryStatsQueryVariables>;
+export declare const GetUserPlatformConnectionsDocument: Apollo.DocumentNode;
+/**
+ * __useGetUserPlatformConnectionsQuery__
+ *
+ * To run a query within a React component, call `useGetUserPlatformConnectionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetUserPlatformConnectionsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetUserPlatformConnectionsQuery({
+ *   variables: {
+ *      channelId: // value for 'channelId'
+ *      filter: // value for 'filter'
+ *      pagination: // value for 'pagination'
+ *      cursor: // value for 'cursor'
+ *   },
+ * });
+ */
+export declare function useGetUserPlatformConnectionsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetUserPlatformConnectionsQuery, Types.GetUserPlatformConnectionsQueryVariables> & ({
+    variables: Types.GetUserPlatformConnectionsQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetUserPlatformConnectionsQuery, Types.GetUserPlatformConnectionsQueryVariables, "empty" | "complete" | "streaming", Types.GetUserPlatformConnectionsQueryVariables>;
+export declare function useGetUserPlatformConnectionsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetUserPlatformConnectionsQuery, Types.GetUserPlatformConnectionsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetUserPlatformConnectionsQuery, Types.GetUserPlatformConnectionsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetUserPlatformConnectionsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetUserPlatformConnectionsQuery, Types.GetUserPlatformConnectionsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetUserPlatformConnectionsQuery, Types.GetUserPlatformConnectionsQueryVariables>;
+export declare function useGetUserPlatformConnectionsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetUserPlatformConnectionsQuery, Types.GetUserPlatformConnectionsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetUserPlatformConnectionsQuery | undefined, Types.GetUserPlatformConnectionsQueryVariables>;
+export type GetUserPlatformConnectionsQueryHookResult = ReturnType<typeof useGetUserPlatformConnectionsQuery>;
+export type GetUserPlatformConnectionsLazyQueryHookResult = ReturnType<typeof useGetUserPlatformConnectionsLazyQuery>;
+export type GetUserPlatformConnectionsSuspenseQueryHookResult = ReturnType<typeof useGetUserPlatformConnectionsSuspenseQuery>;
+export type GetUserPlatformConnectionsQueryResult = Apollo.QueryResult<Types.GetUserPlatformConnectionsQuery, Types.GetUserPlatformConnectionsQueryVariables>;
+export declare const GetWebhookEventsDocument: Apollo.DocumentNode;
+/**
+ * __useGetWebhookEventsQuery__
+ *
+ * To run a query within a React component, call `useGetWebhookEventsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetWebhookEventsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetWebhookEventsQuery({
+ *   variables: {
+ *      channelId: // value for 'channelId'
+ *      limit: // value for 'limit'
+ *      cursor: // value for 'cursor'
+ *   },
+ * });
+ */
+export declare function useGetWebhookEventsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetWebhookEventsQuery, Types.GetWebhookEventsQueryVariables> & ({
+    variables: Types.GetWebhookEventsQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetWebhookEventsQuery, Types.GetWebhookEventsQueryVariables, "empty" | "complete" | "streaming", Types.GetWebhookEventsQueryVariables>;
+export declare function useGetWebhookEventsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetWebhookEventsQuery, Types.GetWebhookEventsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetWebhookEventsQuery, Types.GetWebhookEventsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetWebhookEventsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetWebhookEventsQuery, Types.GetWebhookEventsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetWebhookEventsQuery, Types.GetWebhookEventsQueryVariables>;
+export declare function useGetWebhookEventsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetWebhookEventsQuery, Types.GetWebhookEventsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetWebhookEventsQuery | undefined, Types.GetWebhookEventsQueryVariables>;
+export type GetWebhookEventsQueryHookResult = ReturnType<typeof useGetWebhookEventsQuery>;
+export type GetWebhookEventsLazyQueryHookResult = ReturnType<typeof useGetWebhookEventsLazyQuery>;
+export type GetWebhookEventsSuspenseQueryHookResult = ReturnType<typeof useGetWebhookEventsSuspenseQuery>;
+export type GetWebhookEventsQueryResult = Apollo.QueryResult<Types.GetWebhookEventsQuery, Types.GetWebhookEventsQueryVariables>;
+export declare const SendNotificationDocument: Apollo.DocumentNode;
+export type SendNotificationMutationFn = Apollo.MutationFunction<Types.SendNotificationMutation, Types.SendNotificationMutationVariables>;
+/**
+ * __useSendNotificationMutation__
+ *
+ * To run a mutation, you first call `useSendNotificationMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSendNotificationMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [sendNotificationMutation, { data, loading, error }] = useSendNotificationMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useSendNotificationMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.SendNotificationMutation, Types.SendNotificationMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.SendNotificationMutation, any, Apollo.ApolloCache>;
+export type SendNotificationMutationHookResult = ReturnType<typeof useSendNotificationMutation>;
+export type SendNotificationMutationResult = Apollo.MutationResult<Types.SendNotificationMutation>;
+export type SendNotificationMutationOptions = Apollo.BaseMutationOptions<Types.SendNotificationMutation, Types.SendNotificationMutationVariables>;
+//# sourceMappingURL=global-operations.d.ts.map