@burdenoff/microfe-admin 2026.511.1

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

@@ -0,0 +1,2749 @@
+import * as Types from './global-types';
+import * as Apollo from '@apollo/client';
+import * as ApolloReactHooks from '@apollo/client/react';
+export type TenantFieldsFragment = {
+    __typename?: 'Tenant';
+    id: string;
+    name: string;
+    slug: string;
+    customDomain?: string | null;
+    endpoint?: string | null;
+    status: Types.TenantStatus;
+    type: Types.TenantType;
+    createdAt: string;
+    updatedAt: string;
+    metadata?: Record<string, unknown> | null;
+    config?: {
+        __typename?: 'TenantConfig';
+        complianceRegion?: string | null;
+        customBranding?: Record<string, unknown> | null;
+        dataResidency?: string | null;
+        features?: Record<string, unknown> | null;
+        region?: string | null;
+    } | null;
+};
+export type CreateTenantMutationVariables = Types.Exact<{
+    input: Types.CreateTenantInput;
+}>;
+export type CreateTenantMutation = {
+    __typename?: 'Mutation';
+    createTenant: {
+        __typename?: 'Tenant';
+        id: string;
+        name: string;
+        slug: string;
+        customDomain?: string | null;
+        endpoint?: string | null;
+        status: Types.TenantStatus;
+        type: Types.TenantType;
+        createdAt: string;
+        updatedAt: string;
+        metadata?: Record<string, unknown> | null;
+        config?: {
+            __typename?: 'TenantConfig';
+            complianceRegion?: string | null;
+            customBranding?: Record<string, unknown> | null;
+            dataResidency?: string | null;
+            features?: Record<string, unknown> | null;
+            region?: string | null;
+        } | null;
+    };
+};
+export type GetTenantQueryVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type GetTenantQuery = {
+    __typename?: 'Query';
+    tenant?: {
+        __typename?: 'Tenant';
+        id: string;
+        name: string;
+        slug: string;
+        customDomain?: string | null;
+        endpoint?: string | null;
+        status: Types.TenantStatus;
+        type: Types.TenantType;
+        createdAt: string;
+        updatedAt: string;
+        metadata?: Record<string, unknown> | null;
+        organizations: Array<{
+            __typename?: 'Organization';
+            id: string;
+            name: string;
+        }>;
+        workspaces: Array<{
+            __typename?: 'Workspace';
+            id: string;
+            name: string;
+            status: Types.WorkspaceStatus;
+            endpoint?: string | null;
+            region?: string | null;
+        }>;
+        config?: {
+            __typename?: 'TenantConfig';
+            complianceRegion?: string | null;
+            customBranding?: Record<string, unknown> | null;
+            dataResidency?: string | null;
+            features?: Record<string, unknown> | null;
+            region?: string | null;
+        } | null;
+    } | null;
+};
+export type GetTenantBySlugQueryVariables = Types.Exact<{
+    slug: Types.Scalars['String']['input'];
+}>;
+export type GetTenantBySlugQuery = {
+    __typename?: 'Query';
+    tenantBySlug?: {
+        __typename?: 'Tenant';
+        id: string;
+        name: string;
+        slug: string;
+        customDomain?: string | null;
+        endpoint?: string | null;
+        status: Types.TenantStatus;
+        type: Types.TenantType;
+        createdAt: string;
+        updatedAt: string;
+        metadata?: Record<string, unknown> | null;
+        config?: {
+            __typename?: 'TenantConfig';
+            complianceRegion?: string | null;
+            customBranding?: Record<string, unknown> | null;
+            dataResidency?: string | null;
+            features?: Record<string, unknown> | null;
+            region?: string | null;
+        } | null;
+    } | null;
+};
+export type GetTenantRoutingInfoQueryVariables = Types.Exact<{
+    tenantId: Types.Scalars['ID']['input'];
+}>;
+export type GetTenantRoutingInfoQuery = {
+    __typename?: 'Query';
+    tenantRoutingInfo?: {
+        __typename?: 'TenantRoutingInfo';
+        tenantId: string;
+        type: Types.TenantType;
+        endpoint?: string | null;
+        status: Types.TenantStatus;
+    } | null;
+};
+export type SuspendTenantMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type SuspendTenantMutation = {
+    __typename?: 'Mutation';
+    suspendTenant: {
+        __typename?: 'Tenant';
+        id: string;
+        status: Types.TenantStatus;
+    };
+};
+export type ActivateTenantMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type ActivateTenantMutation = {
+    __typename?: 'Mutation';
+    activateTenant: {
+        __typename?: 'Tenant';
+        id: string;
+        status: Types.TenantStatus;
+    };
+};
+export type ConfigureTenantMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+    input: Types.ConfigureTenantInput;
+}>;
+export type ConfigureTenantMutation = {
+    __typename?: 'Mutation';
+    configureTenant: {
+        __typename?: 'Tenant';
+        id: string;
+        name: string;
+        slug: string;
+        customDomain?: string | null;
+        endpoint?: string | null;
+        status: Types.TenantStatus;
+        type: Types.TenantType;
+        createdAt: string;
+        updatedAt: string;
+        metadata?: Record<string, unknown> | null;
+        config?: {
+            __typename?: 'TenantConfig';
+            complianceRegion?: string | null;
+            customBranding?: Record<string, unknown> | null;
+            dataResidency?: string | null;
+            features?: Record<string, unknown> | null;
+            region?: string | null;
+        } | null;
+    };
+};
+export type ListTenantsQueryVariables = Types.Exact<{
+    filter?: Types.InputMaybe<Types.TenantFilterInput>;
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type ListTenantsQuery = {
+    __typename?: 'Query';
+    tenants: {
+        __typename?: 'TenantList';
+        total: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+        items: Array<{
+            __typename?: 'Tenant';
+            id: string;
+            name: string;
+            slug: string;
+            customDomain?: string | null;
+            endpoint?: string | null;
+            status: Types.TenantStatus;
+            type: Types.TenantType;
+            createdAt: string;
+            updatedAt: string;
+            metadata?: Record<string, unknown> | null;
+            config?: {
+                __typename?: 'TenantConfig';
+                complianceRegion?: string | null;
+                customBranding?: Record<string, unknown> | null;
+                dataResidency?: string | null;
+                features?: Record<string, unknown> | null;
+                region?: string | null;
+            } | null;
+        }>;
+    };
+};
+export type ProvisionDedicatedTenantMutationVariables = Types.Exact<{
+    input: Types.ProvisionDedicatedTenantInput;
+}>;
+export type ProvisionDedicatedTenantMutation = {
+    __typename?: 'Mutation';
+    provisionDedicatedTenant: {
+        __typename?: 'Tenant';
+        id: string;
+        name: string;
+        slug: string;
+        customDomain?: string | null;
+        endpoint?: string | null;
+        status: Types.TenantStatus;
+        type: Types.TenantType;
+        createdAt: string;
+        updatedAt: string;
+        metadata?: Record<string, unknown> | null;
+        config?: {
+            __typename?: 'TenantConfig';
+            complianceRegion?: string | null;
+            customBranding?: Record<string, unknown> | null;
+            dataResidency?: string | null;
+            features?: Record<string, unknown> | null;
+            region?: string | null;
+        } | null;
+    };
+};
+export type SetTenantEndpointMutationVariables = Types.Exact<{
+    tenantId: Types.Scalars['ID']['input'];
+    endpoint: Types.Scalars['String']['input'];
+}>;
+export type SetTenantEndpointMutation = {
+    __typename?: 'Mutation';
+    setTenantEndpoint: {
+        __typename?: 'Tenant';
+        id: string;
+        name: string;
+        slug: string;
+        customDomain?: string | null;
+        endpoint?: string | null;
+        status: Types.TenantStatus;
+        type: Types.TenantType;
+        createdAt: string;
+        updatedAt: string;
+        metadata?: Record<string, unknown> | null;
+        config?: {
+            __typename?: 'TenantConfig';
+            complianceRegion?: string | null;
+            customBranding?: Record<string, unknown> | null;
+            dataResidency?: string | null;
+            features?: Record<string, unknown> | null;
+            region?: string | null;
+        } | null;
+    };
+};
+export type UpdateTenantMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+    input: Types.UpdateTenantInput;
+}>;
+export type UpdateTenantMutation = {
+    __typename?: 'Mutation';
+    updateTenant: {
+        __typename?: 'Tenant';
+        id: string;
+        name: string;
+        slug: string;
+        customDomain?: string | null;
+        endpoint?: string | null;
+        status: Types.TenantStatus;
+        type: Types.TenantType;
+        createdAt: string;
+        updatedAt: string;
+        metadata?: Record<string, unknown> | null;
+        config?: {
+            __typename?: 'TenantConfig';
+            complianceRegion?: string | null;
+            customBranding?: Record<string, unknown> | null;
+            dataResidency?: string | null;
+            features?: Record<string, unknown> | null;
+            region?: string | null;
+        } | null;
+    };
+};
+export type AuditLogFieldsFragment = {
+    __typename?: 'AuditLog';
+    id: string;
+    action: string;
+    actorId: string;
+    actorType: string;
+    resource: string;
+    resourceId?: string | null;
+    tenantId: string;
+    changes?: Record<string, unknown> | null;
+    ipAddress?: string | null;
+    userAgent?: string | null;
+    metadata?: Record<string, unknown> | null;
+    createdAt: string;
+};
+export type ListAuditLogsQueryVariables = Types.Exact<{
+    actorId?: Types.InputMaybe<Types.Scalars['ID']['input']>;
+    resource?: Types.InputMaybe<Types.Scalars['String']['input']>;
+    resourceId?: Types.InputMaybe<Types.Scalars['ID']['input']>;
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type ListAuditLogsQuery = {
+    __typename?: 'Query';
+    auditLogs: {
+        __typename?: 'AuditLogConnection';
+        totalCount: number;
+        edges: Array<{
+            __typename?: 'AuditLogEdge';
+            cursor: string;
+            node: {
+                __typename?: 'AuditLog';
+                id: string;
+                action: string;
+                actorId: string;
+                actorType: string;
+                resource: string;
+                resourceId?: string | null;
+                tenantId: string;
+                changes?: Record<string, unknown> | null;
+                ipAddress?: string | null;
+                userAgent?: string | null;
+                metadata?: Record<string, unknown> | null;
+                createdAt: string;
+            };
+        }>;
+        pageInfo: {
+            __typename?: 'PageInfo';
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            startCursor?: string | null;
+            endCursor?: string | null;
+        };
+    };
+};
+export type ActivityLogFieldsFragment = {
+    __typename?: 'ActivityLog';
+    id: string;
+    action: string;
+    actorId?: string | null;
+    userId?: string | null;
+    resource: string;
+    resourceId?: string | null;
+    resourceType?: string | null;
+    tenantId?: string | null;
+    description?: string | null;
+    ipAddress?: string | null;
+    metadata?: Record<string, unknown> | null;
+    createdAt: string;
+};
+export type ListActivityLogsQueryVariables = Types.Exact<{
+    filter?: Types.InputMaybe<Types.ActivityFilterInput>;
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type ListActivityLogsQuery = {
+    __typename?: 'Query';
+    activityLogs: {
+        __typename?: 'ActivityLogConnection';
+        totalCount: number;
+        hasMore: boolean;
+        nodes: Array<{
+            __typename?: 'ActivityLog';
+            id: string;
+            action: string;
+            actorId?: string | null;
+            userId?: string | null;
+            resource: string;
+            resourceId?: string | null;
+            resourceType?: string | null;
+            tenantId?: string | null;
+            description?: string | null;
+            ipAddress?: string | null;
+            metadata?: Record<string, unknown> | null;
+            createdAt: string;
+        }>;
+    };
+};
+export type ListAllPlansQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type ListAllPlansQuery = {
+    __typename?: 'Query';
+    getAllPlans: Array<{
+        __typename?: 'Plan';
+        id?: string | null;
+        name?: string | null;
+        price?: number | null;
+        currency?: string | null;
+        duration?: Types.PlanDuration | null;
+        isActive?: boolean | null;
+        createdAt?: string | null;
+    }>;
+};
+export type ListAllQuotasQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type ListAllQuotasQuery = {
+    __typename?: 'Query';
+    getAllQuotas: Array<{
+        __typename?: 'Quota';
+        id?: string | null;
+        name?: string | null;
+        quotaType?: Types.QuotaType | null;
+        isActive?: boolean | null;
+    }>;
+};
+export type ListRefundRecordsQueryVariables = Types.Exact<{
+    orgIdFilter?: Types.InputMaybe<Types.Scalars['String']['input']>;
+    page?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    pageSize?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type ListRefundRecordsQuery = {
+    __typename?: 'Query';
+    getRefundRecords: {
+        __typename?: 'PaginatedRefundRecords';
+        totalCount: number;
+        records: Array<{
+            __typename?: 'RefundRecord';
+            id: string;
+            amount: number;
+            currency: string;
+            status: Types.RefundRecordStatus;
+            reason?: string | null;
+            provider: string;
+            createdAt: string;
+        }>;
+    };
+};
+export type ListTaxRatesQueryVariables = Types.Exact<{
+    active?: Types.InputMaybe<Types.Scalars['Boolean']['input']>;
+}>;
+export type ListTaxRatesQuery = {
+    __typename?: 'Query';
+    getTaxRates: Array<{
+        __typename?: 'TaxRate';
+        id: string;
+        country: string;
+        state?: string | null;
+        rate: number;
+        active: boolean;
+    }>;
+};
+export type CreatePlanMutationVariables = Types.Exact<{
+    input: Types.CreatePlanInput;
+}>;
+export type CreatePlanMutation = {
+    __typename?: 'Mutation';
+    createPlan: boolean;
+};
+export type CreateRefundRecordMutationVariables = Types.Exact<{
+    amount: Types.Scalars['Float']['input'];
+    billingAccountId?: Types.InputMaybe<Types.Scalars['String']['input']>;
+    currency: Types.Scalars['String']['input'];
+    gatewayPaymentId: Types.Scalars['String']['input'];
+    provider: Types.Scalars['String']['input'];
+    reason?: Types.InputMaybe<Types.Scalars['String']['input']>;
+}>;
+export type CreateRefundRecordMutation = {
+    __typename?: 'Mutation';
+    createRefundRecord: {
+        __typename?: 'RefundRecord';
+        id: string;
+        status: Types.RefundRecordStatus;
+    };
+};
+export type ListNewslettersQueryVariables = Types.Exact<{
+    filter?: Types.InputMaybe<Types.NewsletterFilterInput>;
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type ListNewslettersQuery = {
+    __typename?: 'Query';
+    newsletters: Array<{
+        __typename?: 'Newsletter';
+        id: string;
+        title: string;
+        subject: string;
+        status: Types.NewsletterStatus;
+        sentAt?: string | null;
+        createdAt: string;
+    }>;
+};
+export type GetNewsletterStatsQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type GetNewsletterStatsQuery = {
+    __typename?: 'Query';
+    newsletterStats: {
+        __typename?: 'NewsletterStats';
+        totalNewsletters: number;
+        totalSubscribers: number;
+        totalSent: number;
+        averageOpenRate?: number | null;
+        averageClickRate?: number | null;
+    };
+};
+export type CreateNewsletterMutationVariables = Types.Exact<{
+    input: Types.CreateNewsletterInput;
+}>;
+export type CreateNewsletterMutation = {
+    __typename?: 'Mutation';
+    createNewsletter: {
+        __typename?: 'Newsletter';
+        id: string;
+        title: string;
+    };
+};
+export type SendNewsletterMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type SendNewsletterMutation = {
+    __typename?: 'Mutation';
+    sendNewsletter: {
+        __typename?: 'Newsletter';
+        id: string;
+        status: Types.NewsletterStatus;
+        sentAt?: string | null;
+    };
+};
+export type GetDashboardTenantCountQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type GetDashboardTenantCountQuery = {
+    __typename?: 'Query';
+    tenants: {
+        __typename?: 'TenantList';
+        total: number;
+    };
+};
+export type GetDashboardOrganizationCountQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type GetDashboardOrganizationCountQuery = {
+    __typename?: 'Query';
+    organizations: {
+        __typename?: 'OrganizationList';
+        total: number;
+    };
+};
+export type GetDashboardActiveWorkspaceCountQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type GetDashboardActiveWorkspaceCountQuery = {
+    __typename?: 'Query';
+    workspaces: {
+        __typename?: 'WorkspaceList';
+        total: number;
+    };
+};
+export type GetDashboardUserCountQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type GetDashboardUserCountQuery = {
+    __typename?: 'Query';
+    userCount: number;
+};
+export type GetDashboardSupportStatsQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type GetDashboardSupportStatsQuery = {
+    __typename?: 'Query';
+    supportStats: {
+        __typename?: 'SupportStats';
+        newTickets: number;
+        openTickets: number;
+        inProgressTickets: number;
+        totalTickets: number;
+    };
+};
+export type GetDashboardTenantsQueryVariables = Types.Exact<{
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type GetDashboardTenantsQuery = {
+    __typename?: 'Query';
+    tenants: {
+        __typename?: 'TenantList';
+        total: number;
+        items: Array<{
+            __typename?: 'Tenant';
+            id: string;
+            name: string;
+            slug: string;
+            status: Types.TenantStatus;
+            createdAt: string;
+        }>;
+    };
+};
+export type GetRecentActivityLogsQueryVariables = Types.Exact<{
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type GetRecentActivityLogsQuery = {
+    __typename?: 'Query';
+    activityLogs: {
+        __typename?: 'ActivityLogConnection';
+        totalCount: number;
+        nodes: Array<{
+            __typename?: 'ActivityLog';
+            id: string;
+            action: string;
+            actorId?: string | null;
+            userId?: string | null;
+            resource: string;
+            resourceId?: string | null;
+            resourceType?: string | null;
+            tenantId?: string | null;
+            description?: string | null;
+            metadata?: Record<string, unknown> | null;
+            createdAt: string;
+        }>;
+    };
+};
+export type ListFeatureFlagsQueryVariables = Types.Exact<{
+    filter?: Types.InputMaybe<Types.FeatureFlagFilterInput>;
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type ListFeatureFlagsQuery = {
+    __typename?: 'Query';
+    featureFlags: {
+        __typename?: 'FeatureFlagList';
+        items: Array<{
+            __typename?: 'FeatureFlag';
+            id: string;
+            key: string;
+            name: string;
+            description?: string | null;
+            flagType: Types.FeatureFlagType;
+            status: Types.FeatureFlagStatus;
+            defaultValue: Record<string, unknown>;
+            createdAt: string;
+            updatedAt: string;
+        }>;
+    };
+};
+export type GetFeatureFlagQueryVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type GetFeatureFlagQuery = {
+    __typename?: 'Query';
+    featureFlag?: {
+        __typename?: 'FeatureFlag';
+        id: string;
+        key: string;
+        name: string;
+        description?: string | null;
+        flagType: Types.FeatureFlagType;
+        status: Types.FeatureFlagStatus;
+        defaultValue: Record<string, unknown>;
+        createdAt: string;
+        updatedAt: string;
+    } | null;
+};
+export type CreateFeatureFlagMutationVariables = Types.Exact<{
+    input: Types.CreateFeatureFlagInput;
+}>;
+export type CreateFeatureFlagMutation = {
+    __typename?: 'Mutation';
+    createFeatureFlag: {
+        __typename?: 'FeatureFlag';
+        id: string;
+        key: string;
+        name: string;
+    };
+};
+export type UpdateFeatureFlagMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+    input: Types.UpdateFeatureFlagInput;
+}>;
+export type UpdateFeatureFlagMutation = {
+    __typename?: 'Mutation';
+    updateFeatureFlag: {
+        __typename?: 'FeatureFlag';
+        id: string;
+        key: string;
+        status: Types.FeatureFlagStatus;
+    };
+};
+export type DeleteFeatureFlagMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type DeleteFeatureFlagMutation = {
+    __typename?: 'Mutation';
+    deleteFeatureFlag: boolean;
+};
+export type ListOrganizationsQueryVariables = Types.Exact<{
+    filter?: Types.InputMaybe<Types.OrganizationFilterInput>;
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type ListOrganizationsQuery = {
+    __typename?: 'Query';
+    organizations: {
+        __typename?: 'OrganizationList';
+        total: number;
+        hasMore: boolean;
+        items: Array<{
+            __typename?: 'Organization';
+            id: string;
+            name: string;
+            slug: string;
+            description?: string | null;
+            status: string;
+            type: string;
+            tenantId: string;
+            createdAt: string;
+        }>;
+    };
+};
+export type UpdateOrganizationMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+    input: Types.UpdateOrganizationInput;
+}>;
+export type UpdateOrganizationMutation = {
+    __typename?: 'Mutation';
+    updateOrganization: {
+        __typename?: 'Organization';
+        id: string;
+        name: string;
+        status: string;
+    };
+};
+export type PlatformProductFieldsFragment = {
+    __typename?: 'PlatformProduct';
+    id: string;
+    name: string;
+    slug: string;
+    description?: string | null;
+    status: Types.PlatformProductStatus;
+    appUrl?: string | null;
+    activeUsers: number;
+    apiCalls: number;
+    contactEmail?: string | null;
+    appStoreUrl?: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+export type ListPlatformProductsQueryVariables = Types.Exact<{
+    filter?: Types.InputMaybe<Types.PlatformProductFilterInput>;
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type ListPlatformProductsQuery = {
+    __typename?: 'Query';
+    platformProducts: {
+        __typename?: 'PlatformProductList';
+        total: number;
+        hasMore: boolean;
+        items: Array<{
+            __typename?: 'PlatformProduct';
+            id: string;
+            name: string;
+            slug: string;
+            description?: string | null;
+            status: Types.PlatformProductStatus;
+            appUrl?: string | null;
+            activeUsers: number;
+            apiCalls: number;
+            contactEmail?: string | null;
+            appStoreUrl?: string | null;
+            createdAt: string;
+            updatedAt: string;
+        }>;
+    };
+};
+export type GetPlatformProductQueryVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type GetPlatformProductQuery = {
+    __typename?: 'Query';
+    platformProduct?: {
+        __typename?: 'PlatformProduct';
+        id: string;
+        name: string;
+        slug: string;
+        description?: string | null;
+        status: Types.PlatformProductStatus;
+        appUrl?: string | null;
+        activeUsers: number;
+        apiCalls: number;
+        contactEmail?: string | null;
+        appStoreUrl?: string | null;
+        createdAt: string;
+        updatedAt: string;
+    } | null;
+};
+export type GetPlatformProductBySlugQueryVariables = Types.Exact<{
+    slug: Types.Scalars['String']['input'];
+}>;
+export type GetPlatformProductBySlugQuery = {
+    __typename?: 'Query';
+    platformProductBySlug?: {
+        __typename?: 'PlatformProduct';
+        id: string;
+        name: string;
+        slug: string;
+        description?: string | null;
+        status: Types.PlatformProductStatus;
+        appUrl?: string | null;
+        activeUsers: number;
+        apiCalls: number;
+        contactEmail?: string | null;
+        appStoreUrl?: string | null;
+        createdAt: string;
+        updatedAt: string;
+    } | null;
+};
+export type GetPlatformProductStatsQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type GetPlatformProductStatsQuery = {
+    __typename?: 'Query';
+    platformProductStats: {
+        __typename?: 'PlatformProductStats';
+        total: number;
+        active: number;
+        draft: number;
+        comingSoon: number;
+        waitlist: number;
+    };
+};
+export type ListRolesQueryVariables = Types.Exact<{
+    scopeId: Types.Scalars['String']['input'];
+}>;
+export type ListRolesQuery = {
+    __typename?: 'Query';
+    roles: Array<{
+        __typename?: 'Role';
+        id: string;
+        name: string;
+        description?: string | null;
+        isSystem: boolean;
+        priority: number;
+        scopeType: string;
+        defaultPermissions: Array<{
+            __typename?: 'RoleDefaultPermission';
+            id: string;
+            resourceType: string;
+            level: Types.RoleLevel;
+        }>;
+    }>;
+};
+export type GetResourceTypesQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type GetResourceTypesQuery = {
+    __typename?: 'Query';
+    resourceTypes: Array<string>;
+};
+export type CreateRoleMutationVariables = Types.Exact<{
+    input: Types.CreateRoleInput;
+}>;
+export type CreateRoleMutation = {
+    __typename?: 'Mutation';
+    createRole: {
+        __typename?: 'Role';
+        id: string;
+        name: string;
+    };
+};
+export type UpdateRoleMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+    input: Types.UpdateRoleInput;
+}>;
+export type UpdateRoleMutation = {
+    __typename?: 'Mutation';
+    updateRole: {
+        __typename?: 'Role';
+        id: string;
+        name: string;
+    };
+};
+export type DeleteRoleMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+    reassignToRoleId?: Types.InputMaybe<Types.Scalars['ID']['input']>;
+}>;
+export type DeleteRoleMutation = {
+    __typename?: 'Mutation';
+    deleteRole: boolean;
+};
+export type SupportTicketFieldsFragment = {
+    __typename?: 'SupportTicket';
+    id: string;
+    subject: string;
+    description: string;
+    status: Types.SupportTicketStatus;
+    priority: Types.SupportTicketPriority;
+    category?: Types.SupportTicketCategory | null;
+    categoryId?: string | null;
+    assignedTo?: string | null;
+    createdAt: string;
+    updatedAt: string;
+    closedAt?: string | null;
+    resolvedAt?: string | null;
+    escalationLevel: number;
+    source: Types.TicketSource;
+    slaBreachStatus: Types.SlaBreachStatus;
+    ticketCategory?: {
+        __typename?: 'TicketCategory';
+        id: string;
+        name: string;
+        slug: string;
+    } | null;
+};
+export type ListSupportTicketsQueryVariables = Types.Exact<{
+    filter?: Types.InputMaybe<Types.SupportTicketFilterInput>;
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type ListSupportTicketsQuery = {
+    __typename?: 'Query';
+    supportTickets: {
+        __typename?: 'SupportTicketConnection';
+        totalCount: number;
+        hasMore: boolean;
+        nodes: Array<{
+            __typename?: 'SupportTicket';
+            id: string;
+            subject: string;
+            description: string;
+            status: Types.SupportTicketStatus;
+            priority: Types.SupportTicketPriority;
+            category?: Types.SupportTicketCategory | null;
+            categoryId?: string | null;
+            assignedTo?: string | null;
+            createdAt: string;
+            updatedAt: string;
+            closedAt?: string | null;
+            resolvedAt?: string | null;
+            escalationLevel: number;
+            source: Types.TicketSource;
+            slaBreachStatus: Types.SlaBreachStatus;
+            ticketCategory?: {
+                __typename?: 'TicketCategory';
+                id: string;
+                name: string;
+                slug: string;
+            } | null;
+        }>;
+    };
+};
+export type GetSupportTicketQueryVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type GetSupportTicketQuery = {
+    __typename?: 'Query';
+    supportTicket?: {
+        __typename?: 'SupportTicket';
+        id: string;
+        subject: string;
+        description: string;
+        status: Types.SupportTicketStatus;
+        priority: Types.SupportTicketPriority;
+        category?: Types.SupportTicketCategory | null;
+        categoryId?: string | null;
+        assignedTo?: string | null;
+        createdAt: string;
+        updatedAt: string;
+        closedAt?: string | null;
+        resolvedAt?: string | null;
+        escalationLevel: number;
+        source: Types.TicketSource;
+        slaBreachStatus: Types.SlaBreachStatus;
+        messages: Array<{
+            __typename?: 'SupportMessage';
+            id: string;
+            message: string;
+            authorId: string;
+            isInternal: boolean;
+            createdAt: string;
+        }>;
+        linkedTickets: Array<{
+            __typename?: 'TicketLink';
+            id: string;
+        }>;
+        ticketCategory?: {
+            __typename?: 'TicketCategory';
+            id: string;
+            name: string;
+            slug: string;
+        } | null;
+    } | null;
+};
+export type GetSupportStatsQueryVariables = Types.Exact<{
+    filter?: Types.InputMaybe<Types.SupportTicketFilterInput>;
+}>;
+export type GetSupportStatsQuery = {
+    __typename?: 'Query';
+    supportStats: {
+        __typename?: 'SupportStats';
+        totalTickets: number;
+        newTickets: number;
+        openTickets: number;
+        inProgressTickets: number;
+        resolvedTickets: number;
+        closedTickets: number;
+        waitingOnCustomerTickets: number;
+        reopenedTickets: number;
+        averageFirstResponseTimeHours?: number | null;
+        averageResolutionTimeHours?: number | null;
+        slaComplianceRate?: number | null;
+    };
+};
+export type SearchSupportTicketsQueryVariables = Types.Exact<{
+    query: Types.Scalars['String']['input'];
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type SearchSupportTicketsQuery = {
+    __typename?: 'Query';
+    searchTickets: Array<{
+        __typename?: 'SupportTicket';
+        id: string;
+        subject: string;
+        description: string;
+        status: Types.SupportTicketStatus;
+        priority: Types.SupportTicketPriority;
+        category?: Types.SupportTicketCategory | null;
+        categoryId?: string | null;
+        assignedTo?: string | null;
+        createdAt: string;
+        updatedAt: string;
+        closedAt?: string | null;
+        resolvedAt?: string | null;
+        escalationLevel: number;
+        source: Types.TicketSource;
+        slaBreachStatus: Types.SlaBreachStatus;
+        ticketCategory?: {
+            __typename?: 'TicketCategory';
+            id: string;
+            name: string;
+            slug: string;
+        } | null;
+    }>;
+};
+export type AssignSupportTicketMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+    assignedTo: Types.Scalars['String']['input'];
+}>;
+export type AssignSupportTicketMutation = {
+    __typename?: 'Mutation';
+    assignSupportTicket: {
+        __typename?: 'SupportTicket';
+        id: string;
+        assignedTo?: string | null;
+        status: Types.SupportTicketStatus;
+    };
+};
+export type CloseSupportTicketMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type CloseSupportTicketMutation = {
+    __typename?: 'Mutation';
+    closeSupportTicket: {
+        __typename?: 'SupportTicket';
+        id: string;
+        status: Types.SupportTicketStatus;
+        closedAt?: string | null;
+    };
+};
+export type AddTicketTagsMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+    tags: Array<Types.Scalars['String']['input']> | Types.Scalars['String']['input'];
+}>;
+export type AddTicketTagsMutation = {
+    __typename?: 'Mutation';
+    addTicketTags: {
+        __typename?: 'SupportTicket';
+        id: string;
+    };
+};
+export type UserFieldsFragment = {
+    __typename?: 'User';
+    id: string;
+    email: string;
+    username: string;
+    firstName?: string | null;
+    lastName?: string | null;
+    name?: string | null;
+    role: string;
+    status: string;
+    tenantId?: string | null;
+    emailVerified: boolean;
+    mfaEnabled: boolean;
+    createdAt: string;
+    updatedAt: string;
+    lastLoginAt?: string | null;
+    defaultWorkspaceId?: string | null;
+};
+export type ListUsersQueryVariables = Types.Exact<{
+    filter?: Types.InputMaybe<Types.UserFilterInput>;
+    pagination?: Types.InputMaybe<Types.PaginationInput>;
+}>;
+export type ListUsersQuery = {
+    __typename?: 'Query';
+    users: {
+        __typename?: 'UserConnection';
+        totalCount: number;
+        hasMore: boolean;
+        users: Array<{
+            __typename?: 'User';
+            id: string;
+            email: string;
+            username: string;
+            firstName?: string | null;
+            lastName?: string | null;
+            name?: string | null;
+            role: string;
+            status: string;
+            tenantId?: string | null;
+            emailVerified: boolean;
+            mfaEnabled: boolean;
+            createdAt: string;
+            updatedAt: string;
+            lastLoginAt?: string | null;
+            defaultWorkspaceId?: string | null;
+        }>;
+    };
+};
+export type GetUserQueryVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type GetUserQuery = {
+    __typename?: 'Query';
+    user?: {
+        __typename?: 'User';
+        id: string;
+        email: string;
+        username: string;
+        firstName?: string | null;
+        lastName?: string | null;
+        name?: string | null;
+        role: string;
+        status: string;
+        tenantId?: string | null;
+        emailVerified: boolean;
+        mfaEnabled: boolean;
+        createdAt: string;
+        updatedAt: string;
+        lastLoginAt?: string | null;
+        defaultWorkspaceId?: string | null;
+    } | null;
+};
+export type GetUserCountQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type GetUserCountQuery = {
+    __typename?: 'Query';
+    userCount: number;
+};
+export type GetCurrentUserQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type GetCurrentUserQuery = {
+    __typename?: 'Query';
+    currentUser?: {
+        __typename?: 'User';
+        id: string;
+        email: string;
+        username: string;
+        firstName?: string | null;
+        lastName?: string | null;
+        name?: string | null;
+        role: string;
+        status: string;
+        tenantId?: string | null;
+        emailVerified: boolean;
+        mfaEnabled: boolean;
+        createdAt: string;
+        updatedAt: string;
+        lastLoginAt?: string | null;
+        defaultWorkspaceId?: string | null;
+    } | null;
+};
+export type UpdateUserMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+    input: Types.AdminUpdateUserInput;
+}>;
+export type UpdateUserMutation = {
+    __typename?: 'Mutation';
+    updateUser: {
+        __typename?: 'User';
+        id: string;
+        email: string;
+        username: string;
+        firstName?: string | null;
+        lastName?: string | null;
+        name?: string | null;
+        role: string;
+        status: string;
+        tenantId?: string | null;
+        emailVerified: boolean;
+        mfaEnabled: boolean;
+        createdAt: string;
+        updatedAt: string;
+        lastLoginAt?: string | null;
+        defaultWorkspaceId?: string | null;
+    };
+};
+export type ListWorkspacesQueryVariables = Types.Exact<{
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type ListWorkspacesQuery = {
+    __typename?: 'Query';
+    workspaces: {
+        __typename?: 'WorkspaceList';
+        total: number;
+        items: Array<{
+            __typename?: 'Workspace';
+            id: string;
+            name: string;
+            status: Types.WorkspaceStatus;
+        }>;
+    };
+};
+export declare const TenantFieldsFragmentDoc: Apollo.DocumentNode;
+export declare const AuditLogFieldsFragmentDoc: Apollo.DocumentNode;
+export declare const ActivityLogFieldsFragmentDoc: Apollo.DocumentNode;
+export declare const PlatformProductFieldsFragmentDoc: Apollo.DocumentNode;
+export declare const SupportTicketFieldsFragmentDoc: Apollo.DocumentNode;
+export declare const UserFieldsFragmentDoc: Apollo.DocumentNode;
+export declare const CreateTenantDocument: Apollo.DocumentNode;
+export type CreateTenantMutationFn = Apollo.MutationFunction<Types.CreateTenantMutation, Types.CreateTenantMutationVariables>;
+/**
+ * __useCreateTenantMutation__
+ *
+ * To run a mutation, you first call `useCreateTenantMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateTenantMutation` 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 [createTenantMutation, { data, loading, error }] = useCreateTenantMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useCreateTenantMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateTenantMutation, Types.CreateTenantMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateTenantMutation, any, Apollo.ApolloCache>;
+export type CreateTenantMutationHookResult = ReturnType<typeof useCreateTenantMutation>;
+export type CreateTenantMutationResult = Apollo.MutationResult<Types.CreateTenantMutation>;
+export type CreateTenantMutationOptions = Apollo.BaseMutationOptions<Types.CreateTenantMutation, Types.CreateTenantMutationVariables>;
+export declare const GetTenantDocument: Apollo.DocumentNode;
+/**
+ * __useGetTenantQuery__
+ *
+ * To run a query within a React component, call `useGetTenantQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetTenantQuery` 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 } = useGetTenantQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useGetTenantQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetTenantQuery, Types.GetTenantQueryVariables> & ({
+    variables: Types.GetTenantQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetTenantQuery, Types.GetTenantQueryVariables, "empty" | "complete" | "streaming", Types.GetTenantQueryVariables>;
+export declare function useGetTenantLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetTenantQuery, Types.GetTenantQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetTenantQuery, Types.GetTenantQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetTenantSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTenantQuery, Types.GetTenantQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTenantQuery, Types.GetTenantQueryVariables>;
+export declare function useGetTenantSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTenantQuery, Types.GetTenantQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTenantQuery | undefined, Types.GetTenantQueryVariables>;
+export type GetTenantQueryHookResult = ReturnType<typeof useGetTenantQuery>;
+export type GetTenantLazyQueryHookResult = ReturnType<typeof useGetTenantLazyQuery>;
+export type GetTenantSuspenseQueryHookResult = ReturnType<typeof useGetTenantSuspenseQuery>;
+export type GetTenantQueryResult = Apollo.QueryResult<Types.GetTenantQuery, Types.GetTenantQueryVariables>;
+export declare const GetTenantBySlugDocument: Apollo.DocumentNode;
+/**
+ * __useGetTenantBySlugQuery__
+ *
+ * To run a query within a React component, call `useGetTenantBySlugQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetTenantBySlugQuery` 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 } = useGetTenantBySlugQuery({
+ *   variables: {
+ *      slug: // value for 'slug'
+ *   },
+ * });
+ */
+export declare function useGetTenantBySlugQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetTenantBySlugQuery, Types.GetTenantBySlugQueryVariables> & ({
+    variables: Types.GetTenantBySlugQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetTenantBySlugQuery, Types.GetTenantBySlugQueryVariables, "empty" | "complete" | "streaming", Types.GetTenantBySlugQueryVariables>;
+export declare function useGetTenantBySlugLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetTenantBySlugQuery, Types.GetTenantBySlugQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetTenantBySlugQuery, Types.GetTenantBySlugQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetTenantBySlugSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTenantBySlugQuery, Types.GetTenantBySlugQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTenantBySlugQuery, Types.GetTenantBySlugQueryVariables>;
+export declare function useGetTenantBySlugSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTenantBySlugQuery, Types.GetTenantBySlugQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTenantBySlugQuery | undefined, Types.GetTenantBySlugQueryVariables>;
+export type GetTenantBySlugQueryHookResult = ReturnType<typeof useGetTenantBySlugQuery>;
+export type GetTenantBySlugLazyQueryHookResult = ReturnType<typeof useGetTenantBySlugLazyQuery>;
+export type GetTenantBySlugSuspenseQueryHookResult = ReturnType<typeof useGetTenantBySlugSuspenseQuery>;
+export type GetTenantBySlugQueryResult = Apollo.QueryResult<Types.GetTenantBySlugQuery, Types.GetTenantBySlugQueryVariables>;
+export declare const GetTenantRoutingInfoDocument: Apollo.DocumentNode;
+/**
+ * __useGetTenantRoutingInfoQuery__
+ *
+ * To run a query within a React component, call `useGetTenantRoutingInfoQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetTenantRoutingInfoQuery` 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 } = useGetTenantRoutingInfoQuery({
+ *   variables: {
+ *      tenantId: // value for 'tenantId'
+ *   },
+ * });
+ */
+export declare function useGetTenantRoutingInfoQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetTenantRoutingInfoQuery, Types.GetTenantRoutingInfoQueryVariables> & ({
+    variables: Types.GetTenantRoutingInfoQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetTenantRoutingInfoQuery, Types.GetTenantRoutingInfoQueryVariables, "empty" | "complete" | "streaming", Types.GetTenantRoutingInfoQueryVariables>;
+export declare function useGetTenantRoutingInfoLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetTenantRoutingInfoQuery, Types.GetTenantRoutingInfoQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetTenantRoutingInfoQuery, Types.GetTenantRoutingInfoQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetTenantRoutingInfoSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTenantRoutingInfoQuery, Types.GetTenantRoutingInfoQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTenantRoutingInfoQuery, Types.GetTenantRoutingInfoQueryVariables>;
+export declare function useGetTenantRoutingInfoSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTenantRoutingInfoQuery, Types.GetTenantRoutingInfoQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTenantRoutingInfoQuery | undefined, Types.GetTenantRoutingInfoQueryVariables>;
+export type GetTenantRoutingInfoQueryHookResult = ReturnType<typeof useGetTenantRoutingInfoQuery>;
+export type GetTenantRoutingInfoLazyQueryHookResult = ReturnType<typeof useGetTenantRoutingInfoLazyQuery>;
+export type GetTenantRoutingInfoSuspenseQueryHookResult = ReturnType<typeof useGetTenantRoutingInfoSuspenseQuery>;
+export type GetTenantRoutingInfoQueryResult = Apollo.QueryResult<Types.GetTenantRoutingInfoQuery, Types.GetTenantRoutingInfoQueryVariables>;
+export declare const SuspendTenantDocument: Apollo.DocumentNode;
+export type SuspendTenantMutationFn = Apollo.MutationFunction<Types.SuspendTenantMutation, Types.SuspendTenantMutationVariables>;
+/**
+ * __useSuspendTenantMutation__
+ *
+ * To run a mutation, you first call `useSuspendTenantMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSuspendTenantMutation` 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 [suspendTenantMutation, { data, loading, error }] = useSuspendTenantMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useSuspendTenantMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.SuspendTenantMutation, Types.SuspendTenantMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.SuspendTenantMutation, any, Apollo.ApolloCache>;
+export type SuspendTenantMutationHookResult = ReturnType<typeof useSuspendTenantMutation>;
+export type SuspendTenantMutationResult = Apollo.MutationResult<Types.SuspendTenantMutation>;
+export type SuspendTenantMutationOptions = Apollo.BaseMutationOptions<Types.SuspendTenantMutation, Types.SuspendTenantMutationVariables>;
+export declare const ActivateTenantDocument: Apollo.DocumentNode;
+export type ActivateTenantMutationFn = Apollo.MutationFunction<Types.ActivateTenantMutation, Types.ActivateTenantMutationVariables>;
+/**
+ * __useActivateTenantMutation__
+ *
+ * To run a mutation, you first call `useActivateTenantMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useActivateTenantMutation` 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 [activateTenantMutation, { data, loading, error }] = useActivateTenantMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useActivateTenantMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ActivateTenantMutation, Types.ActivateTenantMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ActivateTenantMutation, any, Apollo.ApolloCache>;
+export type ActivateTenantMutationHookResult = ReturnType<typeof useActivateTenantMutation>;
+export type ActivateTenantMutationResult = Apollo.MutationResult<Types.ActivateTenantMutation>;
+export type ActivateTenantMutationOptions = Apollo.BaseMutationOptions<Types.ActivateTenantMutation, Types.ActivateTenantMutationVariables>;
+export declare const ConfigureTenantDocument: Apollo.DocumentNode;
+export type ConfigureTenantMutationFn = Apollo.MutationFunction<Types.ConfigureTenantMutation, Types.ConfigureTenantMutationVariables>;
+/**
+ * __useConfigureTenantMutation__
+ *
+ * To run a mutation, you first call `useConfigureTenantMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useConfigureTenantMutation` 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 [configureTenantMutation, { data, loading, error }] = useConfigureTenantMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useConfigureTenantMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ConfigureTenantMutation, Types.ConfigureTenantMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ConfigureTenantMutation, any, Apollo.ApolloCache>;
+export type ConfigureTenantMutationHookResult = ReturnType<typeof useConfigureTenantMutation>;
+export type ConfigureTenantMutationResult = Apollo.MutationResult<Types.ConfigureTenantMutation>;
+export type ConfigureTenantMutationOptions = Apollo.BaseMutationOptions<Types.ConfigureTenantMutation, Types.ConfigureTenantMutationVariables>;
+export declare const ListTenantsDocument: Apollo.DocumentNode;
+/**
+ * __useListTenantsQuery__
+ *
+ * To run a query within a React component, call `useListTenantsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useListTenantsQuery` 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 } = useListTenantsQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      limit: // value for 'limit'
+ *      offset: // value for 'offset'
+ *   },
+ * });
+ */
+export declare function useListTenantsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.ListTenantsQuery, Types.ListTenantsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.ListTenantsQuery, Types.ListTenantsQueryVariables, "empty" | "complete" | "streaming", Types.ListTenantsQueryVariables>;
+export declare function useListTenantsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListTenantsQuery, Types.ListTenantsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListTenantsQuery, Types.ListTenantsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useListTenantsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListTenantsQuery, Types.ListTenantsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListTenantsQuery, Types.ListTenantsQueryVariables>;
+export declare function useListTenantsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListTenantsQuery, Types.ListTenantsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListTenantsQuery | undefined, Types.ListTenantsQueryVariables>;
+export type ListTenantsQueryHookResult = ReturnType<typeof useListTenantsQuery>;
+export type ListTenantsLazyQueryHookResult = ReturnType<typeof useListTenantsLazyQuery>;
+export type ListTenantsSuspenseQueryHookResult = ReturnType<typeof useListTenantsSuspenseQuery>;
+export type ListTenantsQueryResult = Apollo.QueryResult<Types.ListTenantsQuery, Types.ListTenantsQueryVariables>;
+export declare const ProvisionDedicatedTenantDocument: Apollo.DocumentNode;
+export type ProvisionDedicatedTenantMutationFn = Apollo.MutationFunction<Types.ProvisionDedicatedTenantMutation, Types.ProvisionDedicatedTenantMutationVariables>;
+/**
+ * __useProvisionDedicatedTenantMutation__
+ *
+ * To run a mutation, you first call `useProvisionDedicatedTenantMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useProvisionDedicatedTenantMutation` 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 [provisionDedicatedTenantMutation, { data, loading, error }] = useProvisionDedicatedTenantMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useProvisionDedicatedTenantMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ProvisionDedicatedTenantMutation, Types.ProvisionDedicatedTenantMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ProvisionDedicatedTenantMutation, any, Apollo.ApolloCache>;
+export type ProvisionDedicatedTenantMutationHookResult = ReturnType<typeof useProvisionDedicatedTenantMutation>;
+export type ProvisionDedicatedTenantMutationResult = Apollo.MutationResult<Types.ProvisionDedicatedTenantMutation>;
+export type ProvisionDedicatedTenantMutationOptions = Apollo.BaseMutationOptions<Types.ProvisionDedicatedTenantMutation, Types.ProvisionDedicatedTenantMutationVariables>;
+export declare const SetTenantEndpointDocument: Apollo.DocumentNode;
+export type SetTenantEndpointMutationFn = Apollo.MutationFunction<Types.SetTenantEndpointMutation, Types.SetTenantEndpointMutationVariables>;
+/**
+ * __useSetTenantEndpointMutation__
+ *
+ * To run a mutation, you first call `useSetTenantEndpointMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSetTenantEndpointMutation` 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 [setTenantEndpointMutation, { data, loading, error }] = useSetTenantEndpointMutation({
+ *   variables: {
+ *      tenantId: // value for 'tenantId'
+ *      endpoint: // value for 'endpoint'
+ *   },
+ * });
+ */
+export declare function useSetTenantEndpointMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.SetTenantEndpointMutation, Types.SetTenantEndpointMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.SetTenantEndpointMutation, any, Apollo.ApolloCache>;
+export type SetTenantEndpointMutationHookResult = ReturnType<typeof useSetTenantEndpointMutation>;
+export type SetTenantEndpointMutationResult = Apollo.MutationResult<Types.SetTenantEndpointMutation>;
+export type SetTenantEndpointMutationOptions = Apollo.BaseMutationOptions<Types.SetTenantEndpointMutation, Types.SetTenantEndpointMutationVariables>;
+export declare const UpdateTenantDocument: Apollo.DocumentNode;
+export type UpdateTenantMutationFn = Apollo.MutationFunction<Types.UpdateTenantMutation, Types.UpdateTenantMutationVariables>;
+/**
+ * __useUpdateTenantMutation__
+ *
+ * To run a mutation, you first call `useUpdateTenantMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateTenantMutation` 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 [updateTenantMutation, { data, loading, error }] = useUpdateTenantMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useUpdateTenantMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateTenantMutation, Types.UpdateTenantMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateTenantMutation, any, Apollo.ApolloCache>;
+export type UpdateTenantMutationHookResult = ReturnType<typeof useUpdateTenantMutation>;
+export type UpdateTenantMutationResult = Apollo.MutationResult<Types.UpdateTenantMutation>;
+export type UpdateTenantMutationOptions = Apollo.BaseMutationOptions<Types.UpdateTenantMutation, Types.UpdateTenantMutationVariables>;
+export declare const ListAuditLogsDocument: Apollo.DocumentNode;
+/**
+ * __useListAuditLogsQuery__
+ *
+ * To run a query within a React component, call `useListAuditLogsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useListAuditLogsQuery` 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 } = useListAuditLogsQuery({
+ *   variables: {
+ *      actorId: // value for 'actorId'
+ *      resource: // value for 'resource'
+ *      resourceId: // value for 'resourceId'
+ *      limit: // value for 'limit'
+ *      offset: // value for 'offset'
+ *   },
+ * });
+ */
+export declare function useListAuditLogsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.ListAuditLogsQuery, Types.ListAuditLogsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.ListAuditLogsQuery, Types.ListAuditLogsQueryVariables, "empty" | "complete" | "streaming", Types.ListAuditLogsQueryVariables>;
+export declare function useListAuditLogsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListAuditLogsQuery, Types.ListAuditLogsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListAuditLogsQuery, Types.ListAuditLogsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useListAuditLogsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListAuditLogsQuery, Types.ListAuditLogsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListAuditLogsQuery, Types.ListAuditLogsQueryVariables>;
+export declare function useListAuditLogsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListAuditLogsQuery, Types.ListAuditLogsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListAuditLogsQuery | undefined, Types.ListAuditLogsQueryVariables>;
+export type ListAuditLogsQueryHookResult = ReturnType<typeof useListAuditLogsQuery>;
+export type ListAuditLogsLazyQueryHookResult = ReturnType<typeof useListAuditLogsLazyQuery>;
+export type ListAuditLogsSuspenseQueryHookResult = ReturnType<typeof useListAuditLogsSuspenseQuery>;
+export type ListAuditLogsQueryResult = Apollo.QueryResult<Types.ListAuditLogsQuery, Types.ListAuditLogsQueryVariables>;
+export declare const ListActivityLogsDocument: Apollo.DocumentNode;
+/**
+ * __useListActivityLogsQuery__
+ *
+ * To run a query within a React component, call `useListActivityLogsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useListActivityLogsQuery` 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 } = useListActivityLogsQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      limit: // value for 'limit'
+ *      offset: // value for 'offset'
+ *   },
+ * });
+ */
+export declare function useListActivityLogsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.ListActivityLogsQuery, Types.ListActivityLogsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.ListActivityLogsQuery, Types.ListActivityLogsQueryVariables, "empty" | "complete" | "streaming", Types.ListActivityLogsQueryVariables>;
+export declare function useListActivityLogsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListActivityLogsQuery, Types.ListActivityLogsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListActivityLogsQuery, Types.ListActivityLogsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useListActivityLogsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListActivityLogsQuery, Types.ListActivityLogsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListActivityLogsQuery, Types.ListActivityLogsQueryVariables>;
+export declare function useListActivityLogsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListActivityLogsQuery, Types.ListActivityLogsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListActivityLogsQuery | undefined, Types.ListActivityLogsQueryVariables>;
+export type ListActivityLogsQueryHookResult = ReturnType<typeof useListActivityLogsQuery>;
+export type ListActivityLogsLazyQueryHookResult = ReturnType<typeof useListActivityLogsLazyQuery>;
+export type ListActivityLogsSuspenseQueryHookResult = ReturnType<typeof useListActivityLogsSuspenseQuery>;
+export type ListActivityLogsQueryResult = Apollo.QueryResult<Types.ListActivityLogsQuery, Types.ListActivityLogsQueryVariables>;
+export declare const ListAllPlansDocument: Apollo.DocumentNode;
+/**
+ * __useListAllPlansQuery__
+ *
+ * To run a query within a React component, call `useListAllPlansQuery` and pass it any options that fit your needs.
+ * When your component renders, `useListAllPlansQuery` 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 } = useListAllPlansQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useListAllPlansQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.ListAllPlansQuery, Types.ListAllPlansQueryVariables>): ApolloReactHooks.useQuery.Result<Types.ListAllPlansQuery, Types.ListAllPlansQueryVariables, "empty" | "complete" | "streaming", Types.ListAllPlansQueryVariables>;
+export declare function useListAllPlansLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListAllPlansQuery, Types.ListAllPlansQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListAllPlansQuery, Types.ListAllPlansQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useListAllPlansSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListAllPlansQuery, Types.ListAllPlansQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListAllPlansQuery, Types.ListAllPlansQueryVariables>;
+export declare function useListAllPlansSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListAllPlansQuery, Types.ListAllPlansQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListAllPlansQuery | undefined, Types.ListAllPlansQueryVariables>;
+export type ListAllPlansQueryHookResult = ReturnType<typeof useListAllPlansQuery>;
+export type ListAllPlansLazyQueryHookResult = ReturnType<typeof useListAllPlansLazyQuery>;
+export type ListAllPlansSuspenseQueryHookResult = ReturnType<typeof useListAllPlansSuspenseQuery>;
+export type ListAllPlansQueryResult = Apollo.QueryResult<Types.ListAllPlansQuery, Types.ListAllPlansQueryVariables>;
+export declare const ListAllQuotasDocument: Apollo.DocumentNode;
+/**
+ * __useListAllQuotasQuery__
+ *
+ * To run a query within a React component, call `useListAllQuotasQuery` and pass it any options that fit your needs.
+ * When your component renders, `useListAllQuotasQuery` 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 } = useListAllQuotasQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useListAllQuotasQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.ListAllQuotasQuery, Types.ListAllQuotasQueryVariables>): ApolloReactHooks.useQuery.Result<Types.ListAllQuotasQuery, Types.ListAllQuotasQueryVariables, "empty" | "complete" | "streaming", Types.ListAllQuotasQueryVariables>;
+export declare function useListAllQuotasLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListAllQuotasQuery, Types.ListAllQuotasQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListAllQuotasQuery, Types.ListAllQuotasQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useListAllQuotasSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListAllQuotasQuery, Types.ListAllQuotasQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListAllQuotasQuery, Types.ListAllQuotasQueryVariables>;
+export declare function useListAllQuotasSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListAllQuotasQuery, Types.ListAllQuotasQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListAllQuotasQuery | undefined, Types.ListAllQuotasQueryVariables>;
+export type ListAllQuotasQueryHookResult = ReturnType<typeof useListAllQuotasQuery>;
+export type ListAllQuotasLazyQueryHookResult = ReturnType<typeof useListAllQuotasLazyQuery>;
+export type ListAllQuotasSuspenseQueryHookResult = ReturnType<typeof useListAllQuotasSuspenseQuery>;
+export type ListAllQuotasQueryResult = Apollo.QueryResult<Types.ListAllQuotasQuery, Types.ListAllQuotasQueryVariables>;
+export declare const ListRefundRecordsDocument: Apollo.DocumentNode;
+/**
+ * __useListRefundRecordsQuery__
+ *
+ * To run a query within a React component, call `useListRefundRecordsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useListRefundRecordsQuery` 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 } = useListRefundRecordsQuery({
+ *   variables: {
+ *      orgIdFilter: // value for 'orgIdFilter'
+ *      page: // value for 'page'
+ *      pageSize: // value for 'pageSize'
+ *   },
+ * });
+ */
+export declare function useListRefundRecordsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.ListRefundRecordsQuery, Types.ListRefundRecordsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.ListRefundRecordsQuery, Types.ListRefundRecordsQueryVariables, "empty" | "complete" | "streaming", Types.ListRefundRecordsQueryVariables>;
+export declare function useListRefundRecordsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListRefundRecordsQuery, Types.ListRefundRecordsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListRefundRecordsQuery, Types.ListRefundRecordsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useListRefundRecordsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListRefundRecordsQuery, Types.ListRefundRecordsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListRefundRecordsQuery, Types.ListRefundRecordsQueryVariables>;
+export declare function useListRefundRecordsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListRefundRecordsQuery, Types.ListRefundRecordsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListRefundRecordsQuery | undefined, Types.ListRefundRecordsQueryVariables>;
+export type ListRefundRecordsQueryHookResult = ReturnType<typeof useListRefundRecordsQuery>;
+export type ListRefundRecordsLazyQueryHookResult = ReturnType<typeof useListRefundRecordsLazyQuery>;
+export type ListRefundRecordsSuspenseQueryHookResult = ReturnType<typeof useListRefundRecordsSuspenseQuery>;
+export type ListRefundRecordsQueryResult = Apollo.QueryResult<Types.ListRefundRecordsQuery, Types.ListRefundRecordsQueryVariables>;
+export declare const ListTaxRatesDocument: Apollo.DocumentNode;
+/**
+ * __useListTaxRatesQuery__
+ *
+ * To run a query within a React component, call `useListTaxRatesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useListTaxRatesQuery` 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 } = useListTaxRatesQuery({
+ *   variables: {
+ *      active: // value for 'active'
+ *   },
+ * });
+ */
+export declare function useListTaxRatesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.ListTaxRatesQuery, Types.ListTaxRatesQueryVariables>): ApolloReactHooks.useQuery.Result<Types.ListTaxRatesQuery, Types.ListTaxRatesQueryVariables, "empty" | "complete" | "streaming", Types.ListTaxRatesQueryVariables>;
+export declare function useListTaxRatesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListTaxRatesQuery, Types.ListTaxRatesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListTaxRatesQuery, Types.ListTaxRatesQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useListTaxRatesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListTaxRatesQuery, Types.ListTaxRatesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListTaxRatesQuery, Types.ListTaxRatesQueryVariables>;
+export declare function useListTaxRatesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListTaxRatesQuery, Types.ListTaxRatesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListTaxRatesQuery | undefined, Types.ListTaxRatesQueryVariables>;
+export type ListTaxRatesQueryHookResult = ReturnType<typeof useListTaxRatesQuery>;
+export type ListTaxRatesLazyQueryHookResult = ReturnType<typeof useListTaxRatesLazyQuery>;
+export type ListTaxRatesSuspenseQueryHookResult = ReturnType<typeof useListTaxRatesSuspenseQuery>;
+export type ListTaxRatesQueryResult = Apollo.QueryResult<Types.ListTaxRatesQuery, Types.ListTaxRatesQueryVariables>;
+export declare const CreatePlanDocument: Apollo.DocumentNode;
+export type CreatePlanMutationFn = Apollo.MutationFunction<Types.CreatePlanMutation, Types.CreatePlanMutationVariables>;
+/**
+ * __useCreatePlanMutation__
+ *
+ * To run a mutation, you first call `useCreatePlanMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreatePlanMutation` 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 [createPlanMutation, { data, loading, error }] = useCreatePlanMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useCreatePlanMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreatePlanMutation, Types.CreatePlanMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreatePlanMutation, any, Apollo.ApolloCache>;
+export type CreatePlanMutationHookResult = ReturnType<typeof useCreatePlanMutation>;
+export type CreatePlanMutationResult = Apollo.MutationResult<Types.CreatePlanMutation>;
+export type CreatePlanMutationOptions = Apollo.BaseMutationOptions<Types.CreatePlanMutation, Types.CreatePlanMutationVariables>;
+export declare const CreateRefundRecordDocument: Apollo.DocumentNode;
+export type CreateRefundRecordMutationFn = Apollo.MutationFunction<Types.CreateRefundRecordMutation, Types.CreateRefundRecordMutationVariables>;
+/**
+ * __useCreateRefundRecordMutation__
+ *
+ * To run a mutation, you first call `useCreateRefundRecordMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateRefundRecordMutation` 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 [createRefundRecordMutation, { data, loading, error }] = useCreateRefundRecordMutation({
+ *   variables: {
+ *      amount: // value for 'amount'
+ *      billingAccountId: // value for 'billingAccountId'
+ *      currency: // value for 'currency'
+ *      gatewayPaymentId: // value for 'gatewayPaymentId'
+ *      provider: // value for 'provider'
+ *      reason: // value for 'reason'
+ *   },
+ * });
+ */
+export declare function useCreateRefundRecordMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateRefundRecordMutation, Types.CreateRefundRecordMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateRefundRecordMutation, any, Apollo.ApolloCache>;
+export type CreateRefundRecordMutationHookResult = ReturnType<typeof useCreateRefundRecordMutation>;
+export type CreateRefundRecordMutationResult = Apollo.MutationResult<Types.CreateRefundRecordMutation>;
+export type CreateRefundRecordMutationOptions = Apollo.BaseMutationOptions<Types.CreateRefundRecordMutation, Types.CreateRefundRecordMutationVariables>;
+export declare const ListNewslettersDocument: Apollo.DocumentNode;
+/**
+ * __useListNewslettersQuery__
+ *
+ * To run a query within a React component, call `useListNewslettersQuery` and pass it any options that fit your needs.
+ * When your component renders, `useListNewslettersQuery` 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 } = useListNewslettersQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      limit: // value for 'limit'
+ *      offset: // value for 'offset'
+ *   },
+ * });
+ */
+export declare function useListNewslettersQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.ListNewslettersQuery, Types.ListNewslettersQueryVariables>): ApolloReactHooks.useQuery.Result<Types.ListNewslettersQuery, Types.ListNewslettersQueryVariables, "empty" | "complete" | "streaming", Types.ListNewslettersQueryVariables>;
+export declare function useListNewslettersLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListNewslettersQuery, Types.ListNewslettersQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListNewslettersQuery, Types.ListNewslettersQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useListNewslettersSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListNewslettersQuery, Types.ListNewslettersQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListNewslettersQuery, Types.ListNewslettersQueryVariables>;
+export declare function useListNewslettersSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListNewslettersQuery, Types.ListNewslettersQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListNewslettersQuery | undefined, Types.ListNewslettersQueryVariables>;
+export type ListNewslettersQueryHookResult = ReturnType<typeof useListNewslettersQuery>;
+export type ListNewslettersLazyQueryHookResult = ReturnType<typeof useListNewslettersLazyQuery>;
+export type ListNewslettersSuspenseQueryHookResult = ReturnType<typeof useListNewslettersSuspenseQuery>;
+export type ListNewslettersQueryResult = Apollo.QueryResult<Types.ListNewslettersQuery, Types.ListNewslettersQueryVariables>;
+export declare const GetNewsletterStatsDocument: Apollo.DocumentNode;
+/**
+ * __useGetNewsletterStatsQuery__
+ *
+ * To run a query within a React component, call `useGetNewsletterStatsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetNewsletterStatsQuery` 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 } = useGetNewsletterStatsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useGetNewsletterStatsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetNewsletterStatsQuery, Types.GetNewsletterStatsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetNewsletterStatsQuery, Types.GetNewsletterStatsQueryVariables, "empty" | "complete" | "streaming", Types.GetNewsletterStatsQueryVariables>;
+export declare function useGetNewsletterStatsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetNewsletterStatsQuery, Types.GetNewsletterStatsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetNewsletterStatsQuery, Types.GetNewsletterStatsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetNewsletterStatsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetNewsletterStatsQuery, Types.GetNewsletterStatsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetNewsletterStatsQuery, Types.GetNewsletterStatsQueryVariables>;
+export declare function useGetNewsletterStatsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetNewsletterStatsQuery, Types.GetNewsletterStatsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetNewsletterStatsQuery | undefined, Types.GetNewsletterStatsQueryVariables>;
+export type GetNewsletterStatsQueryHookResult = ReturnType<typeof useGetNewsletterStatsQuery>;
+export type GetNewsletterStatsLazyQueryHookResult = ReturnType<typeof useGetNewsletterStatsLazyQuery>;
+export type GetNewsletterStatsSuspenseQueryHookResult = ReturnType<typeof useGetNewsletterStatsSuspenseQuery>;
+export type GetNewsletterStatsQueryResult = Apollo.QueryResult<Types.GetNewsletterStatsQuery, Types.GetNewsletterStatsQueryVariables>;
+export declare const CreateNewsletterDocument: Apollo.DocumentNode;
+export type CreateNewsletterMutationFn = Apollo.MutationFunction<Types.CreateNewsletterMutation, Types.CreateNewsletterMutationVariables>;
+/**
+ * __useCreateNewsletterMutation__
+ *
+ * To run a mutation, you first call `useCreateNewsletterMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateNewsletterMutation` 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 [createNewsletterMutation, { data, loading, error }] = useCreateNewsletterMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useCreateNewsletterMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateNewsletterMutation, Types.CreateNewsletterMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateNewsletterMutation, any, Apollo.ApolloCache>;
+export type CreateNewsletterMutationHookResult = ReturnType<typeof useCreateNewsletterMutation>;
+export type CreateNewsletterMutationResult = Apollo.MutationResult<Types.CreateNewsletterMutation>;
+export type CreateNewsletterMutationOptions = Apollo.BaseMutationOptions<Types.CreateNewsletterMutation, Types.CreateNewsletterMutationVariables>;
+export declare const SendNewsletterDocument: Apollo.DocumentNode;
+export type SendNewsletterMutationFn = Apollo.MutationFunction<Types.SendNewsletterMutation, Types.SendNewsletterMutationVariables>;
+/**
+ * __useSendNewsletterMutation__
+ *
+ * To run a mutation, you first call `useSendNewsletterMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSendNewsletterMutation` 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 [sendNewsletterMutation, { data, loading, error }] = useSendNewsletterMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useSendNewsletterMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.SendNewsletterMutation, Types.SendNewsletterMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.SendNewsletterMutation, any, Apollo.ApolloCache>;
+export type SendNewsletterMutationHookResult = ReturnType<typeof useSendNewsletterMutation>;
+export type SendNewsletterMutationResult = Apollo.MutationResult<Types.SendNewsletterMutation>;
+export type SendNewsletterMutationOptions = Apollo.BaseMutationOptions<Types.SendNewsletterMutation, Types.SendNewsletterMutationVariables>;
+export declare const GetDashboardTenantCountDocument: Apollo.DocumentNode;
+/**
+ * __useGetDashboardTenantCountQuery__
+ *
+ * To run a query within a React component, call `useGetDashboardTenantCountQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetDashboardTenantCountQuery` 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 } = useGetDashboardTenantCountQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useGetDashboardTenantCountQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetDashboardTenantCountQuery, Types.GetDashboardTenantCountQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetDashboardTenantCountQuery, Types.GetDashboardTenantCountQueryVariables, "empty" | "complete" | "streaming", Types.GetDashboardTenantCountQueryVariables>;
+export declare function useGetDashboardTenantCountLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetDashboardTenantCountQuery, Types.GetDashboardTenantCountQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetDashboardTenantCountQuery, Types.GetDashboardTenantCountQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetDashboardTenantCountSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetDashboardTenantCountQuery, Types.GetDashboardTenantCountQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetDashboardTenantCountQuery, Types.GetDashboardTenantCountQueryVariables>;
+export declare function useGetDashboardTenantCountSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetDashboardTenantCountQuery, Types.GetDashboardTenantCountQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetDashboardTenantCountQuery | undefined, Types.GetDashboardTenantCountQueryVariables>;
+export type GetDashboardTenantCountQueryHookResult = ReturnType<typeof useGetDashboardTenantCountQuery>;
+export type GetDashboardTenantCountLazyQueryHookResult = ReturnType<typeof useGetDashboardTenantCountLazyQuery>;
+export type GetDashboardTenantCountSuspenseQueryHookResult = ReturnType<typeof useGetDashboardTenantCountSuspenseQuery>;
+export type GetDashboardTenantCountQueryResult = Apollo.QueryResult<Types.GetDashboardTenantCountQuery, Types.GetDashboardTenantCountQueryVariables>;
+export declare const GetDashboardOrganizationCountDocument: Apollo.DocumentNode;
+/**
+ * __useGetDashboardOrganizationCountQuery__
+ *
+ * To run a query within a React component, call `useGetDashboardOrganizationCountQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetDashboardOrganizationCountQuery` 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 } = useGetDashboardOrganizationCountQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useGetDashboardOrganizationCountQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetDashboardOrganizationCountQuery, Types.GetDashboardOrganizationCountQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetDashboardOrganizationCountQuery, Types.GetDashboardOrganizationCountQueryVariables, "empty" | "complete" | "streaming", Types.GetDashboardOrganizationCountQueryVariables>;
+export declare function useGetDashboardOrganizationCountLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetDashboardOrganizationCountQuery, Types.GetDashboardOrganizationCountQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetDashboardOrganizationCountQuery, Types.GetDashboardOrganizationCountQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetDashboardOrganizationCountSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetDashboardOrganizationCountQuery, Types.GetDashboardOrganizationCountQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetDashboardOrganizationCountQuery, Types.GetDashboardOrganizationCountQueryVariables>;
+export declare function useGetDashboardOrganizationCountSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetDashboardOrganizationCountQuery, Types.GetDashboardOrganizationCountQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetDashboardOrganizationCountQuery | undefined, Types.GetDashboardOrganizationCountQueryVariables>;
+export type GetDashboardOrganizationCountQueryHookResult = ReturnType<typeof useGetDashboardOrganizationCountQuery>;
+export type GetDashboardOrganizationCountLazyQueryHookResult = ReturnType<typeof useGetDashboardOrganizationCountLazyQuery>;
+export type GetDashboardOrganizationCountSuspenseQueryHookResult = ReturnType<typeof useGetDashboardOrganizationCountSuspenseQuery>;
+export type GetDashboardOrganizationCountQueryResult = Apollo.QueryResult<Types.GetDashboardOrganizationCountQuery, Types.GetDashboardOrganizationCountQueryVariables>;
+export declare const GetDashboardActiveWorkspaceCountDocument: Apollo.DocumentNode;
+/**
+ * __useGetDashboardActiveWorkspaceCountQuery__
+ *
+ * To run a query within a React component, call `useGetDashboardActiveWorkspaceCountQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetDashboardActiveWorkspaceCountQuery` 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 } = useGetDashboardActiveWorkspaceCountQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useGetDashboardActiveWorkspaceCountQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetDashboardActiveWorkspaceCountQuery, Types.GetDashboardActiveWorkspaceCountQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetDashboardActiveWorkspaceCountQuery, Types.GetDashboardActiveWorkspaceCountQueryVariables, "empty" | "complete" | "streaming", Types.GetDashboardActiveWorkspaceCountQueryVariables>;
+export declare function useGetDashboardActiveWorkspaceCountLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetDashboardActiveWorkspaceCountQuery, Types.GetDashboardActiveWorkspaceCountQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetDashboardActiveWorkspaceCountQuery, Types.GetDashboardActiveWorkspaceCountQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetDashboardActiveWorkspaceCountSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetDashboardActiveWorkspaceCountQuery, Types.GetDashboardActiveWorkspaceCountQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetDashboardActiveWorkspaceCountQuery, Types.GetDashboardActiveWorkspaceCountQueryVariables>;
+export declare function useGetDashboardActiveWorkspaceCountSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetDashboardActiveWorkspaceCountQuery, Types.GetDashboardActiveWorkspaceCountQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetDashboardActiveWorkspaceCountQuery | undefined, Types.GetDashboardActiveWorkspaceCountQueryVariables>;
+export type GetDashboardActiveWorkspaceCountQueryHookResult = ReturnType<typeof useGetDashboardActiveWorkspaceCountQuery>;
+export type GetDashboardActiveWorkspaceCountLazyQueryHookResult = ReturnType<typeof useGetDashboardActiveWorkspaceCountLazyQuery>;
+export type GetDashboardActiveWorkspaceCountSuspenseQueryHookResult = ReturnType<typeof useGetDashboardActiveWorkspaceCountSuspenseQuery>;
+export type GetDashboardActiveWorkspaceCountQueryResult = Apollo.QueryResult<Types.GetDashboardActiveWorkspaceCountQuery, Types.GetDashboardActiveWorkspaceCountQueryVariables>;
+export declare const GetDashboardUserCountDocument: Apollo.DocumentNode;
+/**
+ * __useGetDashboardUserCountQuery__
+ *
+ * To run a query within a React component, call `useGetDashboardUserCountQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetDashboardUserCountQuery` 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 } = useGetDashboardUserCountQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useGetDashboardUserCountQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetDashboardUserCountQuery, Types.GetDashboardUserCountQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetDashboardUserCountQuery, Types.GetDashboardUserCountQueryVariables, "empty" | "complete" | "streaming", Types.GetDashboardUserCountQueryVariables>;
+export declare function useGetDashboardUserCountLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetDashboardUserCountQuery, Types.GetDashboardUserCountQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetDashboardUserCountQuery, Types.GetDashboardUserCountQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetDashboardUserCountSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetDashboardUserCountQuery, Types.GetDashboardUserCountQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetDashboardUserCountQuery, Types.GetDashboardUserCountQueryVariables>;
+export declare function useGetDashboardUserCountSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetDashboardUserCountQuery, Types.GetDashboardUserCountQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetDashboardUserCountQuery | undefined, Types.GetDashboardUserCountQueryVariables>;
+export type GetDashboardUserCountQueryHookResult = ReturnType<typeof useGetDashboardUserCountQuery>;
+export type GetDashboardUserCountLazyQueryHookResult = ReturnType<typeof useGetDashboardUserCountLazyQuery>;
+export type GetDashboardUserCountSuspenseQueryHookResult = ReturnType<typeof useGetDashboardUserCountSuspenseQuery>;
+export type GetDashboardUserCountQueryResult = Apollo.QueryResult<Types.GetDashboardUserCountQuery, Types.GetDashboardUserCountQueryVariables>;
+export declare const GetDashboardSupportStatsDocument: Apollo.DocumentNode;
+/**
+ * __useGetDashboardSupportStatsQuery__
+ *
+ * To run a query within a React component, call `useGetDashboardSupportStatsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetDashboardSupportStatsQuery` 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 } = useGetDashboardSupportStatsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useGetDashboardSupportStatsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetDashboardSupportStatsQuery, Types.GetDashboardSupportStatsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetDashboardSupportStatsQuery, Types.GetDashboardSupportStatsQueryVariables, "empty" | "complete" | "streaming", Types.GetDashboardSupportStatsQueryVariables>;
+export declare function useGetDashboardSupportStatsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetDashboardSupportStatsQuery, Types.GetDashboardSupportStatsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetDashboardSupportStatsQuery, Types.GetDashboardSupportStatsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetDashboardSupportStatsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetDashboardSupportStatsQuery, Types.GetDashboardSupportStatsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetDashboardSupportStatsQuery, Types.GetDashboardSupportStatsQueryVariables>;
+export declare function useGetDashboardSupportStatsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetDashboardSupportStatsQuery, Types.GetDashboardSupportStatsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetDashboardSupportStatsQuery | undefined, Types.GetDashboardSupportStatsQueryVariables>;
+export type GetDashboardSupportStatsQueryHookResult = ReturnType<typeof useGetDashboardSupportStatsQuery>;
+export type GetDashboardSupportStatsLazyQueryHookResult = ReturnType<typeof useGetDashboardSupportStatsLazyQuery>;
+export type GetDashboardSupportStatsSuspenseQueryHookResult = ReturnType<typeof useGetDashboardSupportStatsSuspenseQuery>;
+export type GetDashboardSupportStatsQueryResult = Apollo.QueryResult<Types.GetDashboardSupportStatsQuery, Types.GetDashboardSupportStatsQueryVariables>;
+export declare const GetDashboardTenantsDocument: Apollo.DocumentNode;
+/**
+ * __useGetDashboardTenantsQuery__
+ *
+ * To run a query within a React component, call `useGetDashboardTenantsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetDashboardTenantsQuery` 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 } = useGetDashboardTenantsQuery({
+ *   variables: {
+ *      limit: // value for 'limit'
+ *   },
+ * });
+ */
+export declare function useGetDashboardTenantsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetDashboardTenantsQuery, Types.GetDashboardTenantsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetDashboardTenantsQuery, Types.GetDashboardTenantsQueryVariables, "empty" | "complete" | "streaming", Types.GetDashboardTenantsQueryVariables>;
+export declare function useGetDashboardTenantsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetDashboardTenantsQuery, Types.GetDashboardTenantsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetDashboardTenantsQuery, Types.GetDashboardTenantsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetDashboardTenantsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetDashboardTenantsQuery, Types.GetDashboardTenantsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetDashboardTenantsQuery, Types.GetDashboardTenantsQueryVariables>;
+export declare function useGetDashboardTenantsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetDashboardTenantsQuery, Types.GetDashboardTenantsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetDashboardTenantsQuery | undefined, Types.GetDashboardTenantsQueryVariables>;
+export type GetDashboardTenantsQueryHookResult = ReturnType<typeof useGetDashboardTenantsQuery>;
+export type GetDashboardTenantsLazyQueryHookResult = ReturnType<typeof useGetDashboardTenantsLazyQuery>;
+export type GetDashboardTenantsSuspenseQueryHookResult = ReturnType<typeof useGetDashboardTenantsSuspenseQuery>;
+export type GetDashboardTenantsQueryResult = Apollo.QueryResult<Types.GetDashboardTenantsQuery, Types.GetDashboardTenantsQueryVariables>;
+export declare const GetRecentActivityLogsDocument: Apollo.DocumentNode;
+/**
+ * __useGetRecentActivityLogsQuery__
+ *
+ * To run a query within a React component, call `useGetRecentActivityLogsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetRecentActivityLogsQuery` 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 } = useGetRecentActivityLogsQuery({
+ *   variables: {
+ *      limit: // value for 'limit'
+ *   },
+ * });
+ */
+export declare function useGetRecentActivityLogsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetRecentActivityLogsQuery, Types.GetRecentActivityLogsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetRecentActivityLogsQuery, Types.GetRecentActivityLogsQueryVariables, "empty" | "complete" | "streaming", Types.GetRecentActivityLogsQueryVariables>;
+export declare function useGetRecentActivityLogsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetRecentActivityLogsQuery, Types.GetRecentActivityLogsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetRecentActivityLogsQuery, Types.GetRecentActivityLogsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetRecentActivityLogsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetRecentActivityLogsQuery, Types.GetRecentActivityLogsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetRecentActivityLogsQuery, Types.GetRecentActivityLogsQueryVariables>;
+export declare function useGetRecentActivityLogsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetRecentActivityLogsQuery, Types.GetRecentActivityLogsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetRecentActivityLogsQuery | undefined, Types.GetRecentActivityLogsQueryVariables>;
+export type GetRecentActivityLogsQueryHookResult = ReturnType<typeof useGetRecentActivityLogsQuery>;
+export type GetRecentActivityLogsLazyQueryHookResult = ReturnType<typeof useGetRecentActivityLogsLazyQuery>;
+export type GetRecentActivityLogsSuspenseQueryHookResult = ReturnType<typeof useGetRecentActivityLogsSuspenseQuery>;
+export type GetRecentActivityLogsQueryResult = Apollo.QueryResult<Types.GetRecentActivityLogsQuery, Types.GetRecentActivityLogsQueryVariables>;
+export declare const ListFeatureFlagsDocument: Apollo.DocumentNode;
+/**
+ * __useListFeatureFlagsQuery__
+ *
+ * To run a query within a React component, call `useListFeatureFlagsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useListFeatureFlagsQuery` 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 } = useListFeatureFlagsQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      limit: // value for 'limit'
+ *      offset: // value for 'offset'
+ *   },
+ * });
+ */
+export declare function useListFeatureFlagsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.ListFeatureFlagsQuery, Types.ListFeatureFlagsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.ListFeatureFlagsQuery, Types.ListFeatureFlagsQueryVariables, "empty" | "complete" | "streaming", Types.ListFeatureFlagsQueryVariables>;
+export declare function useListFeatureFlagsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListFeatureFlagsQuery, Types.ListFeatureFlagsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListFeatureFlagsQuery, Types.ListFeatureFlagsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useListFeatureFlagsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListFeatureFlagsQuery, Types.ListFeatureFlagsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListFeatureFlagsQuery, Types.ListFeatureFlagsQueryVariables>;
+export declare function useListFeatureFlagsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListFeatureFlagsQuery, Types.ListFeatureFlagsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListFeatureFlagsQuery | undefined, Types.ListFeatureFlagsQueryVariables>;
+export type ListFeatureFlagsQueryHookResult = ReturnType<typeof useListFeatureFlagsQuery>;
+export type ListFeatureFlagsLazyQueryHookResult = ReturnType<typeof useListFeatureFlagsLazyQuery>;
+export type ListFeatureFlagsSuspenseQueryHookResult = ReturnType<typeof useListFeatureFlagsSuspenseQuery>;
+export type ListFeatureFlagsQueryResult = Apollo.QueryResult<Types.ListFeatureFlagsQuery, Types.ListFeatureFlagsQueryVariables>;
+export declare const GetFeatureFlagDocument: Apollo.DocumentNode;
+/**
+ * __useGetFeatureFlagQuery__
+ *
+ * To run a query within a React component, call `useGetFeatureFlagQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetFeatureFlagQuery` 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 } = useGetFeatureFlagQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useGetFeatureFlagQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetFeatureFlagQuery, Types.GetFeatureFlagQueryVariables> & ({
+    variables: Types.GetFeatureFlagQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetFeatureFlagQuery, Types.GetFeatureFlagQueryVariables, "empty" | "complete" | "streaming", Types.GetFeatureFlagQueryVariables>;
+export declare function useGetFeatureFlagLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetFeatureFlagQuery, Types.GetFeatureFlagQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetFeatureFlagQuery, Types.GetFeatureFlagQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetFeatureFlagSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFeatureFlagQuery, Types.GetFeatureFlagQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFeatureFlagQuery, Types.GetFeatureFlagQueryVariables>;
+export declare function useGetFeatureFlagSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFeatureFlagQuery, Types.GetFeatureFlagQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFeatureFlagQuery | undefined, Types.GetFeatureFlagQueryVariables>;
+export type GetFeatureFlagQueryHookResult = ReturnType<typeof useGetFeatureFlagQuery>;
+export type GetFeatureFlagLazyQueryHookResult = ReturnType<typeof useGetFeatureFlagLazyQuery>;
+export type GetFeatureFlagSuspenseQueryHookResult = ReturnType<typeof useGetFeatureFlagSuspenseQuery>;
+export type GetFeatureFlagQueryResult = Apollo.QueryResult<Types.GetFeatureFlagQuery, Types.GetFeatureFlagQueryVariables>;
+export declare const CreateFeatureFlagDocument: Apollo.DocumentNode;
+export type CreateFeatureFlagMutationFn = Apollo.MutationFunction<Types.CreateFeatureFlagMutation, Types.CreateFeatureFlagMutationVariables>;
+/**
+ * __useCreateFeatureFlagMutation__
+ *
+ * To run a mutation, you first call `useCreateFeatureFlagMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateFeatureFlagMutation` 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 [createFeatureFlagMutation, { data, loading, error }] = useCreateFeatureFlagMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useCreateFeatureFlagMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateFeatureFlagMutation, Types.CreateFeatureFlagMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateFeatureFlagMutation, any, Apollo.ApolloCache>;
+export type CreateFeatureFlagMutationHookResult = ReturnType<typeof useCreateFeatureFlagMutation>;
+export type CreateFeatureFlagMutationResult = Apollo.MutationResult<Types.CreateFeatureFlagMutation>;
+export type CreateFeatureFlagMutationOptions = Apollo.BaseMutationOptions<Types.CreateFeatureFlagMutation, Types.CreateFeatureFlagMutationVariables>;
+export declare const UpdateFeatureFlagDocument: Apollo.DocumentNode;
+export type UpdateFeatureFlagMutationFn = Apollo.MutationFunction<Types.UpdateFeatureFlagMutation, Types.UpdateFeatureFlagMutationVariables>;
+/**
+ * __useUpdateFeatureFlagMutation__
+ *
+ * To run a mutation, you first call `useUpdateFeatureFlagMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateFeatureFlagMutation` 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 [updateFeatureFlagMutation, { data, loading, error }] = useUpdateFeatureFlagMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useUpdateFeatureFlagMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateFeatureFlagMutation, Types.UpdateFeatureFlagMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateFeatureFlagMutation, any, Apollo.ApolloCache>;
+export type UpdateFeatureFlagMutationHookResult = ReturnType<typeof useUpdateFeatureFlagMutation>;
+export type UpdateFeatureFlagMutationResult = Apollo.MutationResult<Types.UpdateFeatureFlagMutation>;
+export type UpdateFeatureFlagMutationOptions = Apollo.BaseMutationOptions<Types.UpdateFeatureFlagMutation, Types.UpdateFeatureFlagMutationVariables>;
+export declare const DeleteFeatureFlagDocument: Apollo.DocumentNode;
+export type DeleteFeatureFlagMutationFn = Apollo.MutationFunction<Types.DeleteFeatureFlagMutation, Types.DeleteFeatureFlagMutationVariables>;
+/**
+ * __useDeleteFeatureFlagMutation__
+ *
+ * To run a mutation, you first call `useDeleteFeatureFlagMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteFeatureFlagMutation` 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 [deleteFeatureFlagMutation, { data, loading, error }] = useDeleteFeatureFlagMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useDeleteFeatureFlagMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteFeatureFlagMutation, Types.DeleteFeatureFlagMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteFeatureFlagMutation, any, Apollo.ApolloCache>;
+export type DeleteFeatureFlagMutationHookResult = ReturnType<typeof useDeleteFeatureFlagMutation>;
+export type DeleteFeatureFlagMutationResult = Apollo.MutationResult<Types.DeleteFeatureFlagMutation>;
+export type DeleteFeatureFlagMutationOptions = Apollo.BaseMutationOptions<Types.DeleteFeatureFlagMutation, Types.DeleteFeatureFlagMutationVariables>;
+export declare const ListOrganizationsDocument: Apollo.DocumentNode;
+/**
+ * __useListOrganizationsQuery__
+ *
+ * To run a query within a React component, call `useListOrganizationsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useListOrganizationsQuery` 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 } = useListOrganizationsQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      limit: // value for 'limit'
+ *      offset: // value for 'offset'
+ *   },
+ * });
+ */
+export declare function useListOrganizationsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.ListOrganizationsQuery, Types.ListOrganizationsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.ListOrganizationsQuery, Types.ListOrganizationsQueryVariables, "empty" | "complete" | "streaming", Types.ListOrganizationsQueryVariables>;
+export declare function useListOrganizationsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListOrganizationsQuery, Types.ListOrganizationsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListOrganizationsQuery, Types.ListOrganizationsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useListOrganizationsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListOrganizationsQuery, Types.ListOrganizationsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListOrganizationsQuery, Types.ListOrganizationsQueryVariables>;
+export declare function useListOrganizationsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListOrganizationsQuery, Types.ListOrganizationsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListOrganizationsQuery | undefined, Types.ListOrganizationsQueryVariables>;
+export type ListOrganizationsQueryHookResult = ReturnType<typeof useListOrganizationsQuery>;
+export type ListOrganizationsLazyQueryHookResult = ReturnType<typeof useListOrganizationsLazyQuery>;
+export type ListOrganizationsSuspenseQueryHookResult = ReturnType<typeof useListOrganizationsSuspenseQuery>;
+export type ListOrganizationsQueryResult = Apollo.QueryResult<Types.ListOrganizationsQuery, Types.ListOrganizationsQueryVariables>;
+export declare const UpdateOrganizationDocument: Apollo.DocumentNode;
+export type UpdateOrganizationMutationFn = Apollo.MutationFunction<Types.UpdateOrganizationMutation, Types.UpdateOrganizationMutationVariables>;
+/**
+ * __useUpdateOrganizationMutation__
+ *
+ * To run a mutation, you first call `useUpdateOrganizationMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateOrganizationMutation` 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 [updateOrganizationMutation, { data, loading, error }] = useUpdateOrganizationMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useUpdateOrganizationMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateOrganizationMutation, Types.UpdateOrganizationMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateOrganizationMutation, any, Apollo.ApolloCache>;
+export type UpdateOrganizationMutationHookResult = ReturnType<typeof useUpdateOrganizationMutation>;
+export type UpdateOrganizationMutationResult = Apollo.MutationResult<Types.UpdateOrganizationMutation>;
+export type UpdateOrganizationMutationOptions = Apollo.BaseMutationOptions<Types.UpdateOrganizationMutation, Types.UpdateOrganizationMutationVariables>;
+export declare const ListPlatformProductsDocument: Apollo.DocumentNode;
+/**
+ * __useListPlatformProductsQuery__
+ *
+ * To run a query within a React component, call `useListPlatformProductsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useListPlatformProductsQuery` 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 } = useListPlatformProductsQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      limit: // value for 'limit'
+ *      offset: // value for 'offset'
+ *   },
+ * });
+ */
+export declare function useListPlatformProductsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.ListPlatformProductsQuery, Types.ListPlatformProductsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.ListPlatformProductsQuery, Types.ListPlatformProductsQueryVariables, "empty" | "complete" | "streaming", Types.ListPlatformProductsQueryVariables>;
+export declare function useListPlatformProductsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListPlatformProductsQuery, Types.ListPlatformProductsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListPlatformProductsQuery, Types.ListPlatformProductsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useListPlatformProductsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListPlatformProductsQuery, Types.ListPlatformProductsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListPlatformProductsQuery, Types.ListPlatformProductsQueryVariables>;
+export declare function useListPlatformProductsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListPlatformProductsQuery, Types.ListPlatformProductsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListPlatformProductsQuery | undefined, Types.ListPlatformProductsQueryVariables>;
+export type ListPlatformProductsQueryHookResult = ReturnType<typeof useListPlatformProductsQuery>;
+export type ListPlatformProductsLazyQueryHookResult = ReturnType<typeof useListPlatformProductsLazyQuery>;
+export type ListPlatformProductsSuspenseQueryHookResult = ReturnType<typeof useListPlatformProductsSuspenseQuery>;
+export type ListPlatformProductsQueryResult = Apollo.QueryResult<Types.ListPlatformProductsQuery, Types.ListPlatformProductsQueryVariables>;
+export declare const GetPlatformProductDocument: Apollo.DocumentNode;
+/**
+ * __useGetPlatformProductQuery__
+ *
+ * To run a query within a React component, call `useGetPlatformProductQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetPlatformProductQuery` 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 } = useGetPlatformProductQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useGetPlatformProductQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetPlatformProductQuery, Types.GetPlatformProductQueryVariables> & ({
+    variables: Types.GetPlatformProductQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetPlatformProductQuery, Types.GetPlatformProductQueryVariables, "empty" | "complete" | "streaming", Types.GetPlatformProductQueryVariables>;
+export declare function useGetPlatformProductLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetPlatformProductQuery, Types.GetPlatformProductQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetPlatformProductQuery, Types.GetPlatformProductQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetPlatformProductSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetPlatformProductQuery, Types.GetPlatformProductQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetPlatformProductQuery, Types.GetPlatformProductQueryVariables>;
+export declare function useGetPlatformProductSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetPlatformProductQuery, Types.GetPlatformProductQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetPlatformProductQuery | undefined, Types.GetPlatformProductQueryVariables>;
+export type GetPlatformProductQueryHookResult = ReturnType<typeof useGetPlatformProductQuery>;
+export type GetPlatformProductLazyQueryHookResult = ReturnType<typeof useGetPlatformProductLazyQuery>;
+export type GetPlatformProductSuspenseQueryHookResult = ReturnType<typeof useGetPlatformProductSuspenseQuery>;
+export type GetPlatformProductQueryResult = Apollo.QueryResult<Types.GetPlatformProductQuery, Types.GetPlatformProductQueryVariables>;
+export declare const GetPlatformProductBySlugDocument: Apollo.DocumentNode;
+/**
+ * __useGetPlatformProductBySlugQuery__
+ *
+ * To run a query within a React component, call `useGetPlatformProductBySlugQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetPlatformProductBySlugQuery` 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 } = useGetPlatformProductBySlugQuery({
+ *   variables: {
+ *      slug: // value for 'slug'
+ *   },
+ * });
+ */
+export declare function useGetPlatformProductBySlugQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetPlatformProductBySlugQuery, Types.GetPlatformProductBySlugQueryVariables> & ({
+    variables: Types.GetPlatformProductBySlugQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetPlatformProductBySlugQuery, Types.GetPlatformProductBySlugQueryVariables, "empty" | "complete" | "streaming", Types.GetPlatformProductBySlugQueryVariables>;
+export declare function useGetPlatformProductBySlugLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetPlatformProductBySlugQuery, Types.GetPlatformProductBySlugQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetPlatformProductBySlugQuery, Types.GetPlatformProductBySlugQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetPlatformProductBySlugSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetPlatformProductBySlugQuery, Types.GetPlatformProductBySlugQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetPlatformProductBySlugQuery, Types.GetPlatformProductBySlugQueryVariables>;
+export declare function useGetPlatformProductBySlugSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetPlatformProductBySlugQuery, Types.GetPlatformProductBySlugQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetPlatformProductBySlugQuery | undefined, Types.GetPlatformProductBySlugQueryVariables>;
+export type GetPlatformProductBySlugQueryHookResult = ReturnType<typeof useGetPlatformProductBySlugQuery>;
+export type GetPlatformProductBySlugLazyQueryHookResult = ReturnType<typeof useGetPlatformProductBySlugLazyQuery>;
+export type GetPlatformProductBySlugSuspenseQueryHookResult = ReturnType<typeof useGetPlatformProductBySlugSuspenseQuery>;
+export type GetPlatformProductBySlugQueryResult = Apollo.QueryResult<Types.GetPlatformProductBySlugQuery, Types.GetPlatformProductBySlugQueryVariables>;
+export declare const GetPlatformProductStatsDocument: Apollo.DocumentNode;
+/**
+ * __useGetPlatformProductStatsQuery__
+ *
+ * To run a query within a React component, call `useGetPlatformProductStatsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetPlatformProductStatsQuery` 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 } = useGetPlatformProductStatsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useGetPlatformProductStatsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetPlatformProductStatsQuery, Types.GetPlatformProductStatsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetPlatformProductStatsQuery, Types.GetPlatformProductStatsQueryVariables, "empty" | "complete" | "streaming", Types.GetPlatformProductStatsQueryVariables>;
+export declare function useGetPlatformProductStatsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetPlatformProductStatsQuery, Types.GetPlatformProductStatsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetPlatformProductStatsQuery, Types.GetPlatformProductStatsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetPlatformProductStatsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetPlatformProductStatsQuery, Types.GetPlatformProductStatsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetPlatformProductStatsQuery, Types.GetPlatformProductStatsQueryVariables>;
+export declare function useGetPlatformProductStatsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetPlatformProductStatsQuery, Types.GetPlatformProductStatsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetPlatformProductStatsQuery | undefined, Types.GetPlatformProductStatsQueryVariables>;
+export type GetPlatformProductStatsQueryHookResult = ReturnType<typeof useGetPlatformProductStatsQuery>;
+export type GetPlatformProductStatsLazyQueryHookResult = ReturnType<typeof useGetPlatformProductStatsLazyQuery>;
+export type GetPlatformProductStatsSuspenseQueryHookResult = ReturnType<typeof useGetPlatformProductStatsSuspenseQuery>;
+export type GetPlatformProductStatsQueryResult = Apollo.QueryResult<Types.GetPlatformProductStatsQuery, Types.GetPlatformProductStatsQueryVariables>;
+export declare const ListRolesDocument: Apollo.DocumentNode;
+/**
+ * __useListRolesQuery__
+ *
+ * To run a query within a React component, call `useListRolesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useListRolesQuery` 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 } = useListRolesQuery({
+ *   variables: {
+ *      scopeId: // value for 'scopeId'
+ *   },
+ * });
+ */
+export declare function useListRolesQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ListRolesQuery, Types.ListRolesQueryVariables> & ({
+    variables: Types.ListRolesQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.ListRolesQuery, Types.ListRolesQueryVariables, "empty" | "complete" | "streaming", Types.ListRolesQueryVariables>;
+export declare function useListRolesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListRolesQuery, Types.ListRolesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListRolesQuery, Types.ListRolesQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useListRolesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListRolesQuery, Types.ListRolesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListRolesQuery, Types.ListRolesQueryVariables>;
+export declare function useListRolesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListRolesQuery, Types.ListRolesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListRolesQuery | undefined, Types.ListRolesQueryVariables>;
+export type ListRolesQueryHookResult = ReturnType<typeof useListRolesQuery>;
+export type ListRolesLazyQueryHookResult = ReturnType<typeof useListRolesLazyQuery>;
+export type ListRolesSuspenseQueryHookResult = ReturnType<typeof useListRolesSuspenseQuery>;
+export type ListRolesQueryResult = Apollo.QueryResult<Types.ListRolesQuery, Types.ListRolesQueryVariables>;
+export declare const GetResourceTypesDocument: Apollo.DocumentNode;
+/**
+ * __useGetResourceTypesQuery__
+ *
+ * To run a query within a React component, call `useGetResourceTypesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetResourceTypesQuery` 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 } = useGetResourceTypesQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useGetResourceTypesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetResourceTypesQuery, Types.GetResourceTypesQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetResourceTypesQuery, Types.GetResourceTypesQueryVariables, "empty" | "complete" | "streaming", Types.GetResourceTypesQueryVariables>;
+export declare function useGetResourceTypesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetResourceTypesQuery, Types.GetResourceTypesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetResourceTypesQuery, Types.GetResourceTypesQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetResourceTypesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetResourceTypesQuery, Types.GetResourceTypesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetResourceTypesQuery, Types.GetResourceTypesQueryVariables>;
+export declare function useGetResourceTypesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetResourceTypesQuery, Types.GetResourceTypesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetResourceTypesQuery | undefined, Types.GetResourceTypesQueryVariables>;
+export type GetResourceTypesQueryHookResult = ReturnType<typeof useGetResourceTypesQuery>;
+export type GetResourceTypesLazyQueryHookResult = ReturnType<typeof useGetResourceTypesLazyQuery>;
+export type GetResourceTypesSuspenseQueryHookResult = ReturnType<typeof useGetResourceTypesSuspenseQuery>;
+export type GetResourceTypesQueryResult = Apollo.QueryResult<Types.GetResourceTypesQuery, Types.GetResourceTypesQueryVariables>;
+export declare const CreateRoleDocument: Apollo.DocumentNode;
+export type CreateRoleMutationFn = Apollo.MutationFunction<Types.CreateRoleMutation, Types.CreateRoleMutationVariables>;
+/**
+ * __useCreateRoleMutation__
+ *
+ * To run a mutation, you first call `useCreateRoleMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateRoleMutation` 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 [createRoleMutation, { data, loading, error }] = useCreateRoleMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useCreateRoleMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateRoleMutation, Types.CreateRoleMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateRoleMutation, any, Apollo.ApolloCache>;
+export type CreateRoleMutationHookResult = ReturnType<typeof useCreateRoleMutation>;
+export type CreateRoleMutationResult = Apollo.MutationResult<Types.CreateRoleMutation>;
+export type CreateRoleMutationOptions = Apollo.BaseMutationOptions<Types.CreateRoleMutation, Types.CreateRoleMutationVariables>;
+export declare const UpdateRoleDocument: Apollo.DocumentNode;
+export type UpdateRoleMutationFn = Apollo.MutationFunction<Types.UpdateRoleMutation, Types.UpdateRoleMutationVariables>;
+/**
+ * __useUpdateRoleMutation__
+ *
+ * To run a mutation, you first call `useUpdateRoleMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateRoleMutation` 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 [updateRoleMutation, { data, loading, error }] = useUpdateRoleMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useUpdateRoleMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateRoleMutation, Types.UpdateRoleMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateRoleMutation, any, Apollo.ApolloCache>;
+export type UpdateRoleMutationHookResult = ReturnType<typeof useUpdateRoleMutation>;
+export type UpdateRoleMutationResult = Apollo.MutationResult<Types.UpdateRoleMutation>;
+export type UpdateRoleMutationOptions = Apollo.BaseMutationOptions<Types.UpdateRoleMutation, Types.UpdateRoleMutationVariables>;
+export declare const DeleteRoleDocument: Apollo.DocumentNode;
+export type DeleteRoleMutationFn = Apollo.MutationFunction<Types.DeleteRoleMutation, Types.DeleteRoleMutationVariables>;
+/**
+ * __useDeleteRoleMutation__
+ *
+ * To run a mutation, you first call `useDeleteRoleMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteRoleMutation` 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 [deleteRoleMutation, { data, loading, error }] = useDeleteRoleMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      reassignToRoleId: // value for 'reassignToRoleId'
+ *   },
+ * });
+ */
+export declare function useDeleteRoleMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteRoleMutation, Types.DeleteRoleMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteRoleMutation, any, Apollo.ApolloCache>;
+export type DeleteRoleMutationHookResult = ReturnType<typeof useDeleteRoleMutation>;
+export type DeleteRoleMutationResult = Apollo.MutationResult<Types.DeleteRoleMutation>;
+export type DeleteRoleMutationOptions = Apollo.BaseMutationOptions<Types.DeleteRoleMutation, Types.DeleteRoleMutationVariables>;
+export declare const ListSupportTicketsDocument: Apollo.DocumentNode;
+/**
+ * __useListSupportTicketsQuery__
+ *
+ * To run a query within a React component, call `useListSupportTicketsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useListSupportTicketsQuery` 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 } = useListSupportTicketsQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      limit: // value for 'limit'
+ *      offset: // value for 'offset'
+ *   },
+ * });
+ */
+export declare function useListSupportTicketsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.ListSupportTicketsQuery, Types.ListSupportTicketsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.ListSupportTicketsQuery, Types.ListSupportTicketsQueryVariables, "empty" | "complete" | "streaming", Types.ListSupportTicketsQueryVariables>;
+export declare function useListSupportTicketsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListSupportTicketsQuery, Types.ListSupportTicketsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListSupportTicketsQuery, Types.ListSupportTicketsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useListSupportTicketsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListSupportTicketsQuery, Types.ListSupportTicketsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListSupportTicketsQuery, Types.ListSupportTicketsQueryVariables>;
+export declare function useListSupportTicketsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListSupportTicketsQuery, Types.ListSupportTicketsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListSupportTicketsQuery | undefined, Types.ListSupportTicketsQueryVariables>;
+export type ListSupportTicketsQueryHookResult = ReturnType<typeof useListSupportTicketsQuery>;
+export type ListSupportTicketsLazyQueryHookResult = ReturnType<typeof useListSupportTicketsLazyQuery>;
+export type ListSupportTicketsSuspenseQueryHookResult = ReturnType<typeof useListSupportTicketsSuspenseQuery>;
+export type ListSupportTicketsQueryResult = Apollo.QueryResult<Types.ListSupportTicketsQuery, Types.ListSupportTicketsQueryVariables>;
+export declare const GetSupportTicketDocument: Apollo.DocumentNode;
+/**
+ * __useGetSupportTicketQuery__
+ *
+ * To run a query within a React component, call `useGetSupportTicketQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetSupportTicketQuery` 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 } = useGetSupportTicketQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useGetSupportTicketQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetSupportTicketQuery, Types.GetSupportTicketQueryVariables> & ({
+    variables: Types.GetSupportTicketQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetSupportTicketQuery, Types.GetSupportTicketQueryVariables, "empty" | "complete" | "streaming", Types.GetSupportTicketQueryVariables>;
+export declare function useGetSupportTicketLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetSupportTicketQuery, Types.GetSupportTicketQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetSupportTicketQuery, Types.GetSupportTicketQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetSupportTicketSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetSupportTicketQuery, Types.GetSupportTicketQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetSupportTicketQuery, Types.GetSupportTicketQueryVariables>;
+export declare function useGetSupportTicketSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetSupportTicketQuery, Types.GetSupportTicketQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetSupportTicketQuery | undefined, Types.GetSupportTicketQueryVariables>;
+export type GetSupportTicketQueryHookResult = ReturnType<typeof useGetSupportTicketQuery>;
+export type GetSupportTicketLazyQueryHookResult = ReturnType<typeof useGetSupportTicketLazyQuery>;
+export type GetSupportTicketSuspenseQueryHookResult = ReturnType<typeof useGetSupportTicketSuspenseQuery>;
+export type GetSupportTicketQueryResult = Apollo.QueryResult<Types.GetSupportTicketQuery, Types.GetSupportTicketQueryVariables>;
+export declare const GetSupportStatsDocument: Apollo.DocumentNode;
+/**
+ * __useGetSupportStatsQuery__
+ *
+ * To run a query within a React component, call `useGetSupportStatsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetSupportStatsQuery` 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 } = useGetSupportStatsQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *   },
+ * });
+ */
+export declare function useGetSupportStatsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetSupportStatsQuery, Types.GetSupportStatsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetSupportStatsQuery, Types.GetSupportStatsQueryVariables, "empty" | "complete" | "streaming", Types.GetSupportStatsQueryVariables>;
+export declare function useGetSupportStatsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetSupportStatsQuery, Types.GetSupportStatsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetSupportStatsQuery, Types.GetSupportStatsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetSupportStatsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetSupportStatsQuery, Types.GetSupportStatsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetSupportStatsQuery, Types.GetSupportStatsQueryVariables>;
+export declare function useGetSupportStatsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetSupportStatsQuery, Types.GetSupportStatsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetSupportStatsQuery | undefined, Types.GetSupportStatsQueryVariables>;
+export type GetSupportStatsQueryHookResult = ReturnType<typeof useGetSupportStatsQuery>;
+export type GetSupportStatsLazyQueryHookResult = ReturnType<typeof useGetSupportStatsLazyQuery>;
+export type GetSupportStatsSuspenseQueryHookResult = ReturnType<typeof useGetSupportStatsSuspenseQuery>;
+export type GetSupportStatsQueryResult = Apollo.QueryResult<Types.GetSupportStatsQuery, Types.GetSupportStatsQueryVariables>;
+export declare const SearchSupportTicketsDocument: Apollo.DocumentNode;
+/**
+ * __useSearchSupportTicketsQuery__
+ *
+ * To run a query within a React component, call `useSearchSupportTicketsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useSearchSupportTicketsQuery` 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 } = useSearchSupportTicketsQuery({
+ *   variables: {
+ *      query: // value for 'query'
+ *      limit: // value for 'limit'
+ *   },
+ * });
+ */
+export declare function useSearchSupportTicketsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.SearchSupportTicketsQuery, Types.SearchSupportTicketsQueryVariables> & ({
+    variables: Types.SearchSupportTicketsQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.SearchSupportTicketsQuery, Types.SearchSupportTicketsQueryVariables, "empty" | "complete" | "streaming", Types.SearchSupportTicketsQueryVariables>;
+export declare function useSearchSupportTicketsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.SearchSupportTicketsQuery, Types.SearchSupportTicketsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.SearchSupportTicketsQuery, Types.SearchSupportTicketsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useSearchSupportTicketsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.SearchSupportTicketsQuery, Types.SearchSupportTicketsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.SearchSupportTicketsQuery, Types.SearchSupportTicketsQueryVariables>;
+export declare function useSearchSupportTicketsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.SearchSupportTicketsQuery, Types.SearchSupportTicketsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.SearchSupportTicketsQuery | undefined, Types.SearchSupportTicketsQueryVariables>;
+export type SearchSupportTicketsQueryHookResult = ReturnType<typeof useSearchSupportTicketsQuery>;
+export type SearchSupportTicketsLazyQueryHookResult = ReturnType<typeof useSearchSupportTicketsLazyQuery>;
+export type SearchSupportTicketsSuspenseQueryHookResult = ReturnType<typeof useSearchSupportTicketsSuspenseQuery>;
+export type SearchSupportTicketsQueryResult = Apollo.QueryResult<Types.SearchSupportTicketsQuery, Types.SearchSupportTicketsQueryVariables>;
+export declare const AssignSupportTicketDocument: Apollo.DocumentNode;
+export type AssignSupportTicketMutationFn = Apollo.MutationFunction<Types.AssignSupportTicketMutation, Types.AssignSupportTicketMutationVariables>;
+/**
+ * __useAssignSupportTicketMutation__
+ *
+ * To run a mutation, you first call `useAssignSupportTicketMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAssignSupportTicketMutation` 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 [assignSupportTicketMutation, { data, loading, error }] = useAssignSupportTicketMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      assignedTo: // value for 'assignedTo'
+ *   },
+ * });
+ */
+export declare function useAssignSupportTicketMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.AssignSupportTicketMutation, Types.AssignSupportTicketMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.AssignSupportTicketMutation, any, Apollo.ApolloCache>;
+export type AssignSupportTicketMutationHookResult = ReturnType<typeof useAssignSupportTicketMutation>;
+export type AssignSupportTicketMutationResult = Apollo.MutationResult<Types.AssignSupportTicketMutation>;
+export type AssignSupportTicketMutationOptions = Apollo.BaseMutationOptions<Types.AssignSupportTicketMutation, Types.AssignSupportTicketMutationVariables>;
+export declare const CloseSupportTicketDocument: Apollo.DocumentNode;
+export type CloseSupportTicketMutationFn = Apollo.MutationFunction<Types.CloseSupportTicketMutation, Types.CloseSupportTicketMutationVariables>;
+/**
+ * __useCloseSupportTicketMutation__
+ *
+ * To run a mutation, you first call `useCloseSupportTicketMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCloseSupportTicketMutation` 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 [closeSupportTicketMutation, { data, loading, error }] = useCloseSupportTicketMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useCloseSupportTicketMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CloseSupportTicketMutation, Types.CloseSupportTicketMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CloseSupportTicketMutation, any, Apollo.ApolloCache>;
+export type CloseSupportTicketMutationHookResult = ReturnType<typeof useCloseSupportTicketMutation>;
+export type CloseSupportTicketMutationResult = Apollo.MutationResult<Types.CloseSupportTicketMutation>;
+export type CloseSupportTicketMutationOptions = Apollo.BaseMutationOptions<Types.CloseSupportTicketMutation, Types.CloseSupportTicketMutationVariables>;
+export declare const AddTicketTagsDocument: Apollo.DocumentNode;
+export type AddTicketTagsMutationFn = Apollo.MutationFunction<Types.AddTicketTagsMutation, Types.AddTicketTagsMutationVariables>;
+/**
+ * __useAddTicketTagsMutation__
+ *
+ * To run a mutation, you first call `useAddTicketTagsMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAddTicketTagsMutation` 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 [addTicketTagsMutation, { data, loading, error }] = useAddTicketTagsMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      tags: // value for 'tags'
+ *   },
+ * });
+ */
+export declare function useAddTicketTagsMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.AddTicketTagsMutation, Types.AddTicketTagsMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.AddTicketTagsMutation, any, Apollo.ApolloCache>;
+export type AddTicketTagsMutationHookResult = ReturnType<typeof useAddTicketTagsMutation>;
+export type AddTicketTagsMutationResult = Apollo.MutationResult<Types.AddTicketTagsMutation>;
+export type AddTicketTagsMutationOptions = Apollo.BaseMutationOptions<Types.AddTicketTagsMutation, Types.AddTicketTagsMutationVariables>;
+export declare const ListUsersDocument: Apollo.DocumentNode;
+/**
+ * __useListUsersQuery__
+ *
+ * To run a query within a React component, call `useListUsersQuery` and pass it any options that fit your needs.
+ * When your component renders, `useListUsersQuery` 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 } = useListUsersQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export declare function useListUsersQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.ListUsersQuery, Types.ListUsersQueryVariables>): ApolloReactHooks.useQuery.Result<Types.ListUsersQuery, Types.ListUsersQueryVariables, "empty" | "complete" | "streaming", Types.ListUsersQueryVariables>;
+export declare function useListUsersLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListUsersQuery, Types.ListUsersQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListUsersQuery, Types.ListUsersQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useListUsersSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListUsersQuery, Types.ListUsersQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListUsersQuery, Types.ListUsersQueryVariables>;
+export declare function useListUsersSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListUsersQuery, Types.ListUsersQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListUsersQuery | undefined, Types.ListUsersQueryVariables>;
+export type ListUsersQueryHookResult = ReturnType<typeof useListUsersQuery>;
+export type ListUsersLazyQueryHookResult = ReturnType<typeof useListUsersLazyQuery>;
+export type ListUsersSuspenseQueryHookResult = ReturnType<typeof useListUsersSuspenseQuery>;
+export type ListUsersQueryResult = Apollo.QueryResult<Types.ListUsersQuery, Types.ListUsersQueryVariables>;
+export declare const GetUserDocument: Apollo.DocumentNode;
+/**
+ * __useGetUserQuery__
+ *
+ * To run a query within a React component, call `useGetUserQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetUserQuery` 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 } = useGetUserQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useGetUserQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetUserQuery, Types.GetUserQueryVariables> & ({
+    variables: Types.GetUserQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetUserQuery, Types.GetUserQueryVariables, "empty" | "complete" | "streaming", Types.GetUserQueryVariables>;
+export declare function useGetUserLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetUserQuery, Types.GetUserQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetUserQuery, Types.GetUserQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetUserSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetUserQuery, Types.GetUserQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetUserQuery, Types.GetUserQueryVariables>;
+export declare function useGetUserSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetUserQuery, Types.GetUserQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetUserQuery | undefined, Types.GetUserQueryVariables>;
+export type GetUserQueryHookResult = ReturnType<typeof useGetUserQuery>;
+export type GetUserLazyQueryHookResult = ReturnType<typeof useGetUserLazyQuery>;
+export type GetUserSuspenseQueryHookResult = ReturnType<typeof useGetUserSuspenseQuery>;
+export type GetUserQueryResult = Apollo.QueryResult<Types.GetUserQuery, Types.GetUserQueryVariables>;
+export declare const GetUserCountDocument: Apollo.DocumentNode;
+/**
+ * __useGetUserCountQuery__
+ *
+ * To run a query within a React component, call `useGetUserCountQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetUserCountQuery` 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 } = useGetUserCountQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useGetUserCountQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetUserCountQuery, Types.GetUserCountQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetUserCountQuery, Types.GetUserCountQueryVariables, "empty" | "complete" | "streaming", Types.GetUserCountQueryVariables>;
+export declare function useGetUserCountLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetUserCountQuery, Types.GetUserCountQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetUserCountQuery, Types.GetUserCountQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetUserCountSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetUserCountQuery, Types.GetUserCountQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetUserCountQuery, Types.GetUserCountQueryVariables>;
+export declare function useGetUserCountSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetUserCountQuery, Types.GetUserCountQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetUserCountQuery | undefined, Types.GetUserCountQueryVariables>;
+export type GetUserCountQueryHookResult = ReturnType<typeof useGetUserCountQuery>;
+export type GetUserCountLazyQueryHookResult = ReturnType<typeof useGetUserCountLazyQuery>;
+export type GetUserCountSuspenseQueryHookResult = ReturnType<typeof useGetUserCountSuspenseQuery>;
+export type GetUserCountQueryResult = Apollo.QueryResult<Types.GetUserCountQuery, Types.GetUserCountQueryVariables>;
+export declare const GetCurrentUserDocument: Apollo.DocumentNode;
+/**
+ * __useGetCurrentUserQuery__
+ *
+ * To run a query within a React component, call `useGetCurrentUserQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetCurrentUserQuery` 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 } = useGetCurrentUserQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useGetCurrentUserQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetCurrentUserQuery, Types.GetCurrentUserQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetCurrentUserQuery, Types.GetCurrentUserQueryVariables, "empty" | "complete" | "streaming", Types.GetCurrentUserQueryVariables>;
+export declare function useGetCurrentUserLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetCurrentUserQuery, Types.GetCurrentUserQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetCurrentUserQuery, Types.GetCurrentUserQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetCurrentUserSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetCurrentUserQuery, Types.GetCurrentUserQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetCurrentUserQuery, Types.GetCurrentUserQueryVariables>;
+export declare function useGetCurrentUserSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetCurrentUserQuery, Types.GetCurrentUserQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetCurrentUserQuery | undefined, Types.GetCurrentUserQueryVariables>;
+export type GetCurrentUserQueryHookResult = ReturnType<typeof useGetCurrentUserQuery>;
+export type GetCurrentUserLazyQueryHookResult = ReturnType<typeof useGetCurrentUserLazyQuery>;
+export type GetCurrentUserSuspenseQueryHookResult = ReturnType<typeof useGetCurrentUserSuspenseQuery>;
+export type GetCurrentUserQueryResult = Apollo.QueryResult<Types.GetCurrentUserQuery, Types.GetCurrentUserQueryVariables>;
+export declare const UpdateUserDocument: Apollo.DocumentNode;
+export type UpdateUserMutationFn = Apollo.MutationFunction<Types.UpdateUserMutation, Types.UpdateUserMutationVariables>;
+/**
+ * __useUpdateUserMutation__
+ *
+ * To run a mutation, you first call `useUpdateUserMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateUserMutation` 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 [updateUserMutation, { data, loading, error }] = useUpdateUserMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useUpdateUserMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateUserMutation, Types.UpdateUserMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateUserMutation, any, Apollo.ApolloCache>;
+export type UpdateUserMutationHookResult = ReturnType<typeof useUpdateUserMutation>;
+export type UpdateUserMutationResult = Apollo.MutationResult<Types.UpdateUserMutation>;
+export type UpdateUserMutationOptions = Apollo.BaseMutationOptions<Types.UpdateUserMutation, Types.UpdateUserMutationVariables>;
+export declare const ListWorkspacesDocument: Apollo.DocumentNode;
+/**
+ * __useListWorkspacesQuery__
+ *
+ * To run a query within a React component, call `useListWorkspacesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useListWorkspacesQuery` 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 } = useListWorkspacesQuery({
+ *   variables: {
+ *      limit: // value for 'limit'
+ *      offset: // value for 'offset'
+ *   },
+ * });
+ */
+export declare function useListWorkspacesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.ListWorkspacesQuery, Types.ListWorkspacesQueryVariables>): ApolloReactHooks.useQuery.Result<Types.ListWorkspacesQuery, Types.ListWorkspacesQueryVariables, "empty" | "complete" | "streaming", Types.ListWorkspacesQueryVariables>;
+export declare function useListWorkspacesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListWorkspacesQuery, Types.ListWorkspacesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListWorkspacesQuery, Types.ListWorkspacesQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useListWorkspacesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListWorkspacesQuery, Types.ListWorkspacesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListWorkspacesQuery, Types.ListWorkspacesQueryVariables>;
+export declare function useListWorkspacesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListWorkspacesQuery, Types.ListWorkspacesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListWorkspacesQuery | undefined, Types.ListWorkspacesQueryVariables>;
+export type ListWorkspacesQueryHookResult = ReturnType<typeof useListWorkspacesQuery>;
+export type ListWorkspacesLazyQueryHookResult = ReturnType<typeof useListWorkspacesLazyQuery>;
+export type ListWorkspacesSuspenseQueryHookResult = ReturnType<typeof useListWorkspacesSuspenseQuery>;
+export type ListWorkspacesQueryResult = Apollo.QueryResult<Types.ListWorkspacesQuery, Types.ListWorkspacesQueryVariables>;
+//# sourceMappingURL=global-operations.d.ts.map