@stolostron/multicluster-sdk/lib/api/search/search-sdk.d.ts

Provides extensions and APIs that dynamic plugins can use to leverage multicluster capabilities provided by Red Hat Advanced Cluster Management.

import * as Apollo from '@apollo/client';
export type Maybe<T> = T | null;
export type InputMaybe<T> = Maybe<T>;
export type Exact<T extends {
    [key: string]: unknown;
}> = {
    [K in keyof T]: T[K];
};
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]?: Maybe<T[SubKey]>;
};
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]: Maybe<T[SubKey]>;
};
export type MakeEmpty<T extends {
    [key: string]: unknown;
}, K extends keyof T> = {
    [_ in K]?: never;
};
export type Incremental<T> = T | {
    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
};
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
    ID: {
        input: string;
        output: string;
    };
    String: {
        input: string;
        output: string;
    };
    Boolean: {
        input: boolean;
        output: boolean;
    };
    Int: {
        input: number;
        output: number;
    };
    Float: {
        input: number;
        output: number;
    };
    Map: {
        input: any;
        output: any;
    };
};
/** A message is used to communicate conditions detected while executing a query on the server. */
export type Message = {
    /** Message text. */
    description?: Maybe<Scalars['String']['output']>;
    /** Unique identifier to be used by clients to process the message independently of locale or grammatical changes. */
    id: Scalars['String']['output'];
    /**
     * Message type.
     * **Values:** information, warning, error.
     */
    kind?: Maybe<Scalars['String']['output']>;
};
/** Queries supported by the Search Query API. */
export type Query = {
    /**
     * Additional information about the service status or conditions found while processing the query.
     * This is similar to the errors query, but without implying that there was a problem processing the query.
     */
    messages?: Maybe<Array<Maybe<Message>>>;
    /**
     * Search for resources and their relationships.
     * *[PLACEHOLDER] Results only include kubernetes resources for which the authenticated user has list permission.*
     *
     * For more information see the feature spec.
     */
    search?: Maybe<Array<Maybe<SearchResult>>>;
    /**
     * Query all values for the given property.
     * Optionally, a query can be included to filter the results.
     * For example, if we want to get the names of all resources in the namespace foo, we can pass a query with the filter `{property: namespace, values:['foo']}`
     *
     * **Default limit is** 1,000
     * A value of -1 will remove the limit. Use carefully because it may impact the service.
     */
    searchComplete?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
    /**
     * Returns all fields from resources currently in the index.
     * Optionally, a query can be included to filter the results.
     * For example, if we want to only get fields for Pod resources, we can pass a query with the filter `{property: kind, values:['Pod']}`
     */
    searchSchema?: Maybe<Scalars['Map']['output']>;
};
/** Queries supported by the Search Query API. */
export type QuerySearchArgs = {
    input?: InputMaybe<Array<InputMaybe<SearchInput>>>;
};
/** Queries supported by the Search Query API. */
export type QuerySearchCompleteArgs = {
    limit?: InputMaybe<Scalars['Int']['input']>;
    property: Scalars['String']['input'];
    query?: InputMaybe<SearchInput>;
};
/** Queries supported by the Search Query API. */
export type QuerySearchSchemaArgs = {
    query?: InputMaybe<SearchInput>;
};
/**
 * Defines a key/value to filter results.
 * When multiple values are provided for a property, it is interpreted as an OR operation.
 */
export type SearchFilter = {
    /** Name of the property (key). */
    property: Scalars['String']['input'];
    /**
     * Values for the property. Multiple values per property are interpreted as an OR operation.
     * Optionally one of these operations `=,!,!=,>,>=,<,<=` can be included at the beginning of the value.
     * By default the equality operation is used.
     * The values available for datetime fields (Ex: `created`, `startedAt`) are `hour`, `day`, `week`, `month` and `year`.
     * Property `kind`, if included in the filter, will be matched using a case-insensitive comparison.
     * For example, `kind:Pod` and `kind:pod` will bring up all pods. This is to maintain compatibility with Search V1.
     */
    values: Array<InputMaybe<Scalars['String']['input']>>;
};
/** Input options to the search query. */
export type SearchInput = {
    /**
     * List of SearchFilter, which is a key(property) and values.
     * When multiple filters are provided, results will match all filters (AND operation).
     */
    filters?: InputMaybe<Array<InputMaybe<SearchFilter>>>;
    /**
     * List of strings to match resources.
     * Will match resources containing any of the keywords in any text field.
     * When multiple keywords are provided, it is interpreted as an AND operation.
     * Matches are case insensitive.
     */
    keywords?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
    /**
     * Max number of results returned by the query.
     * **Default is** 10,000
     * A value of -1 will remove the limit. Use carefully because it may impact the service.
     */
    limit?: InputMaybe<Scalars['Int']['input']>;
    /**
     * Filter relationships to the specified kinds.
     * If empty, all relationships will be included.
     * This filter is used with the 'related' field on SearchResult.
     */
    relatedKinds?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
};
/** Resources related to the items resolved from the search query. */
export type SearchRelatedResult = {
    /**
     * Total number of related resources.
     * **NOTE:** Should not use count in combination with items. If items are requested, the count is simply the size of items.
     */
    count?: Maybe<Scalars['Int']['output']>;
    /** Resources matched by the query. */
    items?: Maybe<Array<Maybe<Scalars['Map']['output']>>>;
    kind: Scalars['String']['output'];
};
/** Data returned by the search query. */
export type SearchResult = {
    /**
     * Total number of resources matching the query.
     * **NOTE:** Should not use count in combination with items. If items are requested, the count is simply the size of items.
     */
    count?: Maybe<Scalars['Int']['output']>;
    /** Resources matching the search query. */
    items?: Maybe<Array<Maybe<Scalars['Map']['output']>>>;
    /**
     * Resources related to the query results (items).
     * For example, if searching for deployments, this will return the related pod resources.
     */
    related?: Maybe<Array<Maybe<SearchRelatedResult>>>;
};
export type SearchSchemaQueryVariables = Exact<{
    query?: InputMaybe<SearchInput>;
}>;
export type SearchSchemaQuery = {
    searchSchema?: any | null;
};
export type SearchCompleteQueryVariables = Exact<{
    property: Scalars['String']['input'];
    query?: InputMaybe<SearchInput>;
    limit?: InputMaybe<Scalars['Int']['input']>;
}>;
export type SearchCompleteQuery = {
    searchComplete?: Array<string | null> | null;
};
export type SearchResultItemsQueryVariables = Exact<{
    input?: InputMaybe<Array<InputMaybe<SearchInput>> | InputMaybe<SearchInput>>;
}>;
export type SearchResultItemsQuery = {
    searchResult?: Array<{
        items?: Array<any | null> | null;
    } | null> | null;
};
export type SearchResultCountQueryVariables = Exact<{
    input?: InputMaybe<Array<InputMaybe<SearchInput>> | InputMaybe<SearchInput>>;
}>;
export type SearchResultCountQuery = {
    searchResult?: Array<{
        count?: number | null;
    } | null> | null;
};
export type SearchResultRelatedCountQueryVariables = Exact<{
    input?: InputMaybe<Array<InputMaybe<SearchInput>> | InputMaybe<SearchInput>>;
}>;
export type SearchResultRelatedCountQuery = {
    searchResult?: Array<{
        related?: Array<{
            kind: string;
            count?: number | null;
        } | null> | null;
    } | null> | null;
};
export type SearchResultItemsAndRelatedItemsQueryVariables = Exact<{
    input?: InputMaybe<Array<InputMaybe<SearchInput>> | InputMaybe<SearchInput>>;
}>;
export type SearchResultItemsAndRelatedItemsQuery = {
    searchResult?: Array<{
        items?: Array<any | null> | null;
        related?: Array<{
            kind: string;
            items?: Array<any | null> | null;
        } | null> | null;
    } | null> | null;
};
export type SearchResultRelatedItemsQueryVariables = Exact<{
    input?: InputMaybe<Array<InputMaybe<SearchInput>> | InputMaybe<SearchInput>>;
}>;
export type SearchResultRelatedItemsQuery = {
    searchResult?: Array<{
        related?: Array<{
            kind: string;
            items?: Array<any | null> | null;
        } | null> | null;
    } | null> | null;
};
export type GetMessagesQueryVariables = Exact<{
    [key: string]: never;
}>;
export type GetMessagesQuery = {
    messages?: Array<{
        id: string;
        kind?: string | null;
        description?: string | null;
    } | null> | null;
};
export declare const SearchSchemaDocument: Apollo.DocumentNode;
/**
 * __useSearchSchemaQuery__
 *
 * To run a query within a React component, call `useSearchSchemaQuery` and pass it any options that fit your needs.
 * When your component renders, `useSearchSchemaQuery` 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 } = useSearchSchemaQuery({
 *   variables: {
 *      query: // value for 'query'
 *   },
 * });
 */
export declare function useSearchSchemaQuery(baseOptions?: Apollo.QueryHookOptions<SearchSchemaQuery, SearchSchemaQueryVariables>): Apollo.QueryResult<SearchSchemaQuery, Exact<{
    query?: InputMaybe<SearchInput>;
}>>;
export declare function useSearchSchemaLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SearchSchemaQuery, SearchSchemaQueryVariables>): Apollo.LazyQueryResultTuple<SearchSchemaQuery, Exact<{
    query?: InputMaybe<SearchInput>;
}>>;
export declare function useSearchSchemaSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<SearchSchemaQuery, SearchSchemaQueryVariables>): Apollo.UseSuspenseQueryResult<SearchSchemaQuery | undefined, Exact<{
    query?: InputMaybe<SearchInput>;
}>>;
export type SearchSchemaQueryHookResult = ReturnType<typeof useSearchSchemaQuery>;
export type SearchSchemaLazyQueryHookResult = ReturnType<typeof useSearchSchemaLazyQuery>;
export type SearchSchemaSuspenseQueryHookResult = ReturnType<typeof useSearchSchemaSuspenseQuery>;
export type SearchSchemaQueryResult = Apollo.QueryResult<SearchSchemaQuery, SearchSchemaQueryVariables>;
export declare const SearchCompleteDocument: Apollo.DocumentNode;
/**
 * __useSearchCompleteQuery__
 *
 * To run a query within a React component, call `useSearchCompleteQuery` and pass it any options that fit your needs.
 * When your component renders, `useSearchCompleteQuery` 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 } = useSearchCompleteQuery({
 *   variables: {
 *      property: // value for 'property'
 *      query: // value for 'query'
 *      limit: // value for 'limit'
 *   },
 * });
 */
export declare function useSearchCompleteQuery(baseOptions: Apollo.QueryHookOptions<SearchCompleteQuery, SearchCompleteQueryVariables> & ({
    variables: SearchCompleteQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): Apollo.QueryResult<SearchCompleteQuery, Exact<{
    property: Scalars["String"]["input"];
    query?: InputMaybe<SearchInput>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
}>>;
export declare function useSearchCompleteLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SearchCompleteQuery, SearchCompleteQueryVariables>): Apollo.LazyQueryResultTuple<SearchCompleteQuery, Exact<{
    property: Scalars["String"]["input"];
    query?: InputMaybe<SearchInput>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
}>>;
export declare function useSearchCompleteSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<SearchCompleteQuery, SearchCompleteQueryVariables>): Apollo.UseSuspenseQueryResult<SearchCompleteQuery | undefined, Exact<{
    property: Scalars["String"]["input"];
    query?: InputMaybe<SearchInput>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
}>>;
export type SearchCompleteQueryHookResult = ReturnType<typeof useSearchCompleteQuery>;
export type SearchCompleteLazyQueryHookResult = ReturnType<typeof useSearchCompleteLazyQuery>;
export type SearchCompleteSuspenseQueryHookResult = ReturnType<typeof useSearchCompleteSuspenseQuery>;
export type SearchCompleteQueryResult = Apollo.QueryResult<SearchCompleteQuery, SearchCompleteQueryVariables>;
export declare const SearchResultItemsDocument: Apollo.DocumentNode;
/**
 * __useSearchResultItemsQuery__
 *
 * To run a query within a React component, call `useSearchResultItemsQuery` and pass it any options that fit your needs.
 * When your component renders, `useSearchResultItemsQuery` 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 } = useSearchResultItemsQuery({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useSearchResultItemsQuery(baseOptions?: Apollo.QueryHookOptions<SearchResultItemsQuery, SearchResultItemsQueryVariables>): Apollo.QueryResult<SearchResultItemsQuery, Exact<{
    input?: InputMaybe<Array<InputMaybe<SearchInput>> | InputMaybe<SearchInput>>;
}>>;
export declare function useSearchResultItemsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SearchResultItemsQuery, SearchResultItemsQueryVariables>): Apollo.LazyQueryResultTuple<SearchResultItemsQuery, Exact<{
    input?: InputMaybe<Array<InputMaybe<SearchInput>> | InputMaybe<SearchInput>>;
}>>;
export declare function useSearchResultItemsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<SearchResultItemsQuery, SearchResultItemsQueryVariables>): Apollo.UseSuspenseQueryResult<SearchResultItemsQuery | undefined, Exact<{
    input?: InputMaybe<Array<InputMaybe<SearchInput>> | InputMaybe<SearchInput>>;
}>>;
export type SearchResultItemsQueryHookResult = ReturnType<typeof useSearchResultItemsQuery>;
export type SearchResultItemsLazyQueryHookResult = ReturnType<typeof useSearchResultItemsLazyQuery>;
export type SearchResultItemsSuspenseQueryHookResult = ReturnType<typeof useSearchResultItemsSuspenseQuery>;
export type SearchResultItemsQueryResult = Apollo.QueryResult<SearchResultItemsQuery, SearchResultItemsQueryVariables>;
export declare const SearchResultCountDocument: Apollo.DocumentNode;
/**
 * __useSearchResultCountQuery__
 *
 * To run a query within a React component, call `useSearchResultCountQuery` and pass it any options that fit your needs.
 * When your component renders, `useSearchResultCountQuery` 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 } = useSearchResultCountQuery({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useSearchResultCountQuery(baseOptions?: Apollo.QueryHookOptions<SearchResultCountQuery, SearchResultCountQueryVariables>): Apollo.QueryResult<SearchResultCountQuery, Exact<{
    input?: InputMaybe<Array<InputMaybe<SearchInput>> | InputMaybe<SearchInput>>;
}>>;
export declare function useSearchResultCountLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SearchResultCountQuery, SearchResultCountQueryVariables>): Apollo.LazyQueryResultTuple<SearchResultCountQuery, Exact<{
    input?: InputMaybe<Array<InputMaybe<SearchInput>> | InputMaybe<SearchInput>>;
}>>;
export declare function useSearchResultCountSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<SearchResultCountQuery, SearchResultCountQueryVariables>): Apollo.UseSuspenseQueryResult<SearchResultCountQuery | undefined, Exact<{
    input?: InputMaybe<Array<InputMaybe<SearchInput>> | InputMaybe<SearchInput>>;
}>>;
export type SearchResultCountQueryHookResult = ReturnType<typeof useSearchResultCountQuery>;
export type SearchResultCountLazyQueryHookResult = ReturnType<typeof useSearchResultCountLazyQuery>;
export type SearchResultCountSuspenseQueryHookResult = ReturnType<typeof useSearchResultCountSuspenseQuery>;
export type SearchResultCountQueryResult = Apollo.QueryResult<SearchResultCountQuery, SearchResultCountQueryVariables>;
export declare const SearchResultRelatedCountDocument: Apollo.DocumentNode;
/**
 * __useSearchResultRelatedCountQuery__
 *
 * To run a query within a React component, call `useSearchResultRelatedCountQuery` and pass it any options that fit your needs.
 * When your component renders, `useSearchResultRelatedCountQuery` 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 } = useSearchResultRelatedCountQuery({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useSearchResultRelatedCountQuery(baseOptions?: Apollo.QueryHookOptions<SearchResultRelatedCountQuery, SearchResultRelatedCountQueryVariables>): Apollo.QueryResult<SearchResultRelatedCountQuery, Exact<{
    input?: InputMaybe<Array<InputMaybe<SearchInput>> | InputMaybe<SearchInput>>;
}>>;
export declare function useSearchResultRelatedCountLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SearchResultRelatedCountQuery, SearchResultRelatedCountQueryVariables>): Apollo.LazyQueryResultTuple<SearchResultRelatedCountQuery, Exact<{
    input?: InputMaybe<Array<InputMaybe<SearchInput>> | InputMaybe<SearchInput>>;
}>>;
export declare function useSearchResultRelatedCountSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<SearchResultRelatedCountQuery, SearchResultRelatedCountQueryVariables>): Apollo.UseSuspenseQueryResult<SearchResultRelatedCountQuery | undefined, Exact<{
    input?: InputMaybe<Array<InputMaybe<SearchInput>> | InputMaybe<SearchInput>>;
}>>;
export type SearchResultRelatedCountQueryHookResult = ReturnType<typeof useSearchResultRelatedCountQuery>;
export type SearchResultRelatedCountLazyQueryHookResult = ReturnType<typeof useSearchResultRelatedCountLazyQuery>;
export type SearchResultRelatedCountSuspenseQueryHookResult = ReturnType<typeof useSearchResultRelatedCountSuspenseQuery>;
export type SearchResultRelatedCountQueryResult = Apollo.QueryResult<SearchResultRelatedCountQuery, SearchResultRelatedCountQueryVariables>;
export declare const SearchResultItemsAndRelatedItemsDocument: Apollo.DocumentNode;
/**
 * __useSearchResultItemsAndRelatedItemsQuery__
 *
 * To run a query within a React component, call `useSearchResultItemsAndRelatedItemsQuery` and pass it any options that fit your needs.
 * When your component renders, `useSearchResultItemsAndRelatedItemsQuery` 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 } = useSearchResultItemsAndRelatedItemsQuery({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useSearchResultItemsAndRelatedItemsQuery(baseOptions?: Apollo.QueryHookOptions<SearchResultItemsAndRelatedItemsQuery, SearchResultItemsAndRelatedItemsQueryVariables>): Apollo.QueryResult<SearchResultItemsAndRelatedItemsQuery, Exact<{
    input?: InputMaybe<Array<InputMaybe<SearchInput>> | InputMaybe<SearchInput>>;
}>>;
export declare function useSearchResultItemsAndRelatedItemsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SearchResultItemsAndRelatedItemsQuery, SearchResultItemsAndRelatedItemsQueryVariables>): Apollo.LazyQueryResultTuple<SearchResultItemsAndRelatedItemsQuery, Exact<{
    input?: InputMaybe<Array<InputMaybe<SearchInput>> | InputMaybe<SearchInput>>;
}>>;
export declare function useSearchResultItemsAndRelatedItemsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<SearchResultItemsAndRelatedItemsQuery, SearchResultItemsAndRelatedItemsQueryVariables>): Apollo.UseSuspenseQueryResult<SearchResultItemsAndRelatedItemsQuery | undefined, Exact<{
    input?: InputMaybe<Array<InputMaybe<SearchInput>> | InputMaybe<SearchInput>>;
}>>;
export type SearchResultItemsAndRelatedItemsQueryHookResult = ReturnType<typeof useSearchResultItemsAndRelatedItemsQuery>;
export type SearchResultItemsAndRelatedItemsLazyQueryHookResult = ReturnType<typeof useSearchResultItemsAndRelatedItemsLazyQuery>;
export type SearchResultItemsAndRelatedItemsSuspenseQueryHookResult = ReturnType<typeof useSearchResultItemsAndRelatedItemsSuspenseQuery>;
export type SearchResultItemsAndRelatedItemsQueryResult = Apollo.QueryResult<SearchResultItemsAndRelatedItemsQuery, SearchResultItemsAndRelatedItemsQueryVariables>;
export declare const SearchResultRelatedItemsDocument: Apollo.DocumentNode;
/**
 * __useSearchResultRelatedItemsQuery__
 *
 * To run a query within a React component, call `useSearchResultRelatedItemsQuery` and pass it any options that fit your needs.
 * When your component renders, `useSearchResultRelatedItemsQuery` 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 } = useSearchResultRelatedItemsQuery({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useSearchResultRelatedItemsQuery(baseOptions?: Apollo.QueryHookOptions<SearchResultRelatedItemsQuery, SearchResultRelatedItemsQueryVariables>): Apollo.QueryResult<SearchResultRelatedItemsQuery, Exact<{
    input?: InputMaybe<Array<InputMaybe<SearchInput>> | InputMaybe<SearchInput>>;
}>>;
export declare function useSearchResultRelatedItemsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SearchResultRelatedItemsQuery, SearchResultRelatedItemsQueryVariables>): Apollo.LazyQueryResultTuple<SearchResultRelatedItemsQuery, Exact<{
    input?: InputMaybe<Array<InputMaybe<SearchInput>> | InputMaybe<SearchInput>>;
}>>;
export declare function useSearchResultRelatedItemsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<SearchResultRelatedItemsQuery, SearchResultRelatedItemsQueryVariables>): Apollo.UseSuspenseQueryResult<SearchResultRelatedItemsQuery | undefined, Exact<{
    input?: InputMaybe<Array<InputMaybe<SearchInput>> | InputMaybe<SearchInput>>;
}>>;
export type SearchResultRelatedItemsQueryHookResult = ReturnType<typeof useSearchResultRelatedItemsQuery>;
export type SearchResultRelatedItemsLazyQueryHookResult = ReturnType<typeof useSearchResultRelatedItemsLazyQuery>;
export type SearchResultRelatedItemsSuspenseQueryHookResult = ReturnType<typeof useSearchResultRelatedItemsSuspenseQuery>;
export type SearchResultRelatedItemsQueryResult = Apollo.QueryResult<SearchResultRelatedItemsQuery, SearchResultRelatedItemsQueryVariables>;
export declare const GetMessagesDocument: Apollo.DocumentNode;
/**
 * __useGetMessagesQuery__
 *
 * To run a query within a React component, call `useGetMessagesQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetMessagesQuery` 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 } = useGetMessagesQuery({
 *   variables: {
 *   },
 * });
 */
export declare function useGetMessagesQuery(baseOptions?: Apollo.QueryHookOptions<GetMessagesQuery, GetMessagesQueryVariables>): Apollo.QueryResult<GetMessagesQuery, Exact<{
    [key: string]: never;
}>>;
export declare function useGetMessagesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetMessagesQuery, GetMessagesQueryVariables>): Apollo.LazyQueryResultTuple<GetMessagesQuery, Exact<{
    [key: string]: never;
}>>;
export declare function useGetMessagesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetMessagesQuery, GetMessagesQueryVariables>): Apollo.UseSuspenseQueryResult<GetMessagesQuery | undefined, Exact<{
    [key: string]: never;
}>>;
export type GetMessagesQueryHookResult = ReturnType<typeof useGetMessagesQuery>;
export type GetMessagesLazyQueryHookResult = ReturnType<typeof useGetMessagesLazyQuery>;
export type GetMessagesSuspenseQueryHookResult = ReturnType<typeof useGetMessagesSuspenseQuery>;
export type GetMessagesQueryResult = Apollo.QueryResult<GetMessagesQuery, GetMessagesQueryVariables>;
//# sourceMappingURL=search-sdk.d.ts.map