Files

584 lines
24 KiB
TypeScript
Raw Permalink Normal View History

import * as VueApolloComposable from '@vue/apollo-composable'
import gql from 'graphql-tag'
import type * as VueCompositionApi from 'vue'
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 }
export type ReactiveFunction<TParam> = () => TParam
/** 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 }
Time: { input: any; output: any }
}
export type ApiKey = {
__typename?: 'APIKey'
id: Scalars['ID']['output']
key?: Maybe<Scalars['String']['output']>
name: Scalars['String']['output']
organization: Organization
publish: Scalars['Boolean']['output']
read: Scalars['Boolean']['output']
refs: Array<Scalars['String']['output']>
}
export type InputApiKey = {
name: Scalars['String']['input']
organizationId: Scalars['ID']['input']
publish: Scalars['Boolean']['input']
read: Scalars['Boolean']['input']
refs: Array<Scalars['String']['input']>
}
export type InputSubGraph = {
ref: Scalars['String']['input']
sdl: Scalars['String']['input']
service: Scalars['String']['input']
url?: InputMaybe<Scalars['String']['input']>
wsUrl?: InputMaybe<Scalars['String']['input']>
}
export type Mutation = {
__typename?: 'Mutation'
addAPIKey: ApiKey
addOrganization: Organization
addUserToOrganization: Organization
removeAPIKey: Organization
removeOrganization: Scalars['Boolean']['output']
updateSubGraph: SubGraph
}
export type MutationAddApiKeyArgs = {
input?: InputMaybe<InputApiKey>
}
export type MutationAddOrganizationArgs = {
name: Scalars['String']['input']
}
export type MutationAddUserToOrganizationArgs = {
organizationId: Scalars['ID']['input']
userId: Scalars['String']['input']
}
export type MutationRemoveApiKeyArgs = {
keyName: Scalars['String']['input']
organizationId: Scalars['ID']['input']
}
export type MutationRemoveOrganizationArgs = {
organizationId: Scalars['ID']['input']
}
export type MutationUpdateSubGraphArgs = {
input: InputSubGraph
}
export type Organization = {
__typename?: 'Organization'
apiKeys: Array<ApiKey>
id: Scalars['ID']['output']
name: Scalars['String']['output']
users: Array<User>
}
export type Query = {
__typename?: 'Query'
allOrganizations: Array<Organization>
latestSchema: SchemaUpdate
organizations: Array<Organization>
supergraph: Supergraph
}
export type QueryLatestSchemaArgs = {
ref: Scalars['String']['input']
}
export type QuerySupergraphArgs = {
isAfter?: InputMaybe<Scalars['String']['input']>
ref: Scalars['String']['input']
}
export type SchemaUpdate = {
__typename?: 'SchemaUpdate'
cosmoRouterConfig?: Maybe<Scalars['String']['output']>
id: Scalars['ID']['output']
ref: Scalars['String']['output']
subGraphs: Array<SubGraph>
}
export type SubGraph = {
__typename?: 'SubGraph'
changedAt: Scalars['Time']['output']
changedBy: Scalars['String']['output']
id: Scalars['ID']['output']
sdl: Scalars['String']['output']
service: Scalars['String']['output']
url?: Maybe<Scalars['String']['output']>
wsUrl?: Maybe<Scalars['String']['output']>
}
export type SubGraphs = {
__typename?: 'SubGraphs'
id: Scalars['ID']['output']
minDelaySeconds: Scalars['Int']['output']
sdl: Scalars['String']['output']
subGraphs: Array<SubGraph>
}
export type Subscription = {
__typename?: 'Subscription'
schemaUpdates: SchemaUpdate
}
export type SubscriptionSchemaUpdatesArgs = {
ref: Scalars['String']['input']
}
export type Supergraph = SubGraphs | Unchanged
export type Unchanged = {
__typename?: 'Unchanged'
id: Scalars['ID']['output']
minDelaySeconds: Scalars['Int']['output']
}
export type User = {
__typename?: 'User'
id: Scalars['String']['output']
}
export type OrganizationsQueryVariables = Exact<{ [key: string]: never }>
export type OrganizationsQuery = { __typename?: 'Query'; organizations: Array<{ __typename?: 'Organization'; id: string; name: string; users: Array<{ __typename?: 'User'; id: string }>; apiKeys: Array<{ __typename?: 'APIKey'; id: string; name: string; refs: Array<string>; read: boolean; publish: boolean }> }> }
export type AllOrganizationsQueryVariables = Exact<{ [key: string]: never }>
export type AllOrganizationsQuery = { __typename?: 'Query'; allOrganizations: Array<{ __typename?: 'Organization'; id: string; name: string; users: Array<{ __typename?: 'User'; id: string }>; apiKeys: Array<{ __typename?: 'APIKey'; id: string; name: string; refs: Array<string>; read: boolean; publish: boolean }> }> }
export type LatestSchemaQueryVariables = Exact<{
ref: Scalars['String']['input']
}>
export type LatestSchemaQuery = { __typename?: 'Query'; latestSchema: { __typename?: 'SchemaUpdate'; ref: string; id: string; cosmoRouterConfig?: string | null; subGraphs: Array<{ __typename?: 'SubGraph'; id: string; service: string; url?: string | null; wsUrl?: string | null; sdl: string; changedBy: string; changedAt: any }> } }
export type SupergraphQueryVariables = Exact<{
ref: Scalars['String']['input']
isAfter?: InputMaybe<Scalars['String']['input']>
}>
export type SupergraphQuery = { __typename?: 'Query', supergraph:
| { __typename?: 'SubGraphs'; id: string; sdl: string; subGraphs: Array<{ __typename?: 'SubGraph'; id: string; service: string; url?: string | null; wsUrl?: string | null; sdl: string; changedBy: string; changedAt: any }> }
| { __typename?: 'Unchanged'; id: string; minDelaySeconds: number }
}
export type AddOrganizationMutationVariables = Exact<{
name: Scalars['String']['input']
}>
export type AddOrganizationMutation = { __typename?: 'Mutation'; addOrganization: { __typename?: 'Organization'; id: string; name: string; users: Array<{ __typename?: 'User'; id: string }>; apiKeys: Array<{ __typename?: 'APIKey'; id: string; name: string; refs: Array<string>; read: boolean; publish: boolean }> } }
export type AddUserToOrganizationMutationVariables = Exact<{
organizationId: Scalars['ID']['input']
userId: Scalars['String']['input']
}>
export type AddUserToOrganizationMutation = { __typename?: 'Mutation'; addUserToOrganization: { __typename?: 'Organization'; id: string; name: string; users: Array<{ __typename?: 'User'; id: string }>; apiKeys: Array<{ __typename?: 'APIKey'; id: string; name: string; refs: Array<string>; read: boolean; publish: boolean }> } }
export type AddApiKeyMutationVariables = Exact<{
input: InputApiKey
}>
export type AddApiKeyMutation = { __typename?: 'Mutation'; addAPIKey: { __typename?: 'APIKey'; id: string; name: string; key?: string | null; refs: Array<string>; read: boolean; publish: boolean; organization: { __typename?: 'Organization'; id: string; name: string } } }
export type RemoveApiKeyMutationVariables = Exact<{
organizationId: Scalars['ID']['input']
keyName: Scalars['String']['input']
}>
export type RemoveApiKeyMutation = { __typename?: 'Mutation'; removeAPIKey: { __typename?: 'Organization'; id: string; name: string; users: Array<{ __typename?: 'User'; id: string }>; apiKeys: Array<{ __typename?: 'APIKey'; id: string; name: string; refs: Array<string>; read: boolean; publish: boolean }> } }
export type RemoveOrganizationMutationVariables = Exact<{
organizationId: Scalars['ID']['input']
}>
export type RemoveOrganizationMutation = { __typename?: 'Mutation'; removeOrganization: boolean }
export const OrganizationsDocument = gql`
query Organizations {
organizations {
id
name
users {
id
}
apiKeys {
id
name
refs
read
publish
}
}
}
`
/**
* __useOrganizationsQuery__
*
* To run a query within a Vue component, call `useOrganizationsQuery` and pass it any options that fit your needs.
* When your component renders, `useOrganizationsQuery` returns an object from Apollo Client that contains result, loading and error properties
* you can use to render your UI.
*
* @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
*
* @example
* const { result, loading, error } = useOrganizationsQuery();
*/
export function useOrganizationsQuery(options: VueApolloComposable.UseQueryOptions<OrganizationsQuery, OrganizationsQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<OrganizationsQuery, OrganizationsQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<OrganizationsQuery, OrganizationsQueryVariables>> = {}) {
return VueApolloComposable.useQuery<OrganizationsQuery, OrganizationsQueryVariables>(OrganizationsDocument, {}, options)
}
export function useOrganizationsLazyQuery(options: VueApolloComposable.UseQueryOptions<OrganizationsQuery, OrganizationsQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<OrganizationsQuery, OrganizationsQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<OrganizationsQuery, OrganizationsQueryVariables>> = {}) {
return VueApolloComposable.useLazyQuery<OrganizationsQuery, OrganizationsQueryVariables>(OrganizationsDocument, {}, options)
}
export type OrganizationsQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<OrganizationsQuery, OrganizationsQueryVariables>
export const AllOrganizationsDocument = gql`
query AllOrganizations {
allOrganizations {
id
name
users {
id
}
apiKeys {
id
name
refs
read
publish
}
}
}
`
/**
* __useAllOrganizationsQuery__
*
* To run a query within a Vue component, call `useAllOrganizationsQuery` and pass it any options that fit your needs.
* When your component renders, `useAllOrganizationsQuery` returns an object from Apollo Client that contains result, loading and error properties
* you can use to render your UI.
*
* @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
*
* @example
* const { result, loading, error } = useAllOrganizationsQuery();
*/
export function useAllOrganizationsQuery(options: VueApolloComposable.UseQueryOptions<AllOrganizationsQuery, AllOrganizationsQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<AllOrganizationsQuery, AllOrganizationsQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<AllOrganizationsQuery, AllOrganizationsQueryVariables>> = {}) {
return VueApolloComposable.useQuery<AllOrganizationsQuery, AllOrganizationsQueryVariables>(AllOrganizationsDocument, {}, options)
}
export function useAllOrganizationsLazyQuery(options: VueApolloComposable.UseQueryOptions<AllOrganizationsQuery, AllOrganizationsQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<AllOrganizationsQuery, AllOrganizationsQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<AllOrganizationsQuery, AllOrganizationsQueryVariables>> = {}) {
return VueApolloComposable.useLazyQuery<AllOrganizationsQuery, AllOrganizationsQueryVariables>(AllOrganizationsDocument, {}, options)
}
export type AllOrganizationsQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<AllOrganizationsQuery, AllOrganizationsQueryVariables>
export const LatestSchemaDocument = gql`
query LatestSchema($ref: String!) {
latestSchema(ref: $ref) {
ref
id
subGraphs {
id
service
url
wsUrl
sdl
changedBy
changedAt
}
cosmoRouterConfig
}
}
`
/**
* __useLatestSchemaQuery__
*
* To run a query within a Vue component, call `useLatestSchemaQuery` and pass it any options that fit your needs.
* When your component renders, `useLatestSchemaQuery` returns an object from Apollo Client that contains result, loading and error properties
* you can use to render your UI.
*
* @param variables that will be passed into the query
* @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
*
* @example
* const { result, loading, error } = useLatestSchemaQuery({
* ref: // value for 'ref'
* });
*/
export function useLatestSchemaQuery(variables: LatestSchemaQueryVariables | VueCompositionApi.Ref<LatestSchemaQueryVariables> | ReactiveFunction<LatestSchemaQueryVariables>, options: VueApolloComposable.UseQueryOptions<LatestSchemaQuery, LatestSchemaQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<LatestSchemaQuery, LatestSchemaQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<LatestSchemaQuery, LatestSchemaQueryVariables>> = {}) {
return VueApolloComposable.useQuery<LatestSchemaQuery, LatestSchemaQueryVariables>(LatestSchemaDocument, variables, options)
}
export function useLatestSchemaLazyQuery(variables?: LatestSchemaQueryVariables | VueCompositionApi.Ref<LatestSchemaQueryVariables> | ReactiveFunction<LatestSchemaQueryVariables>, options: VueApolloComposable.UseQueryOptions<LatestSchemaQuery, LatestSchemaQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<LatestSchemaQuery, LatestSchemaQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<LatestSchemaQuery, LatestSchemaQueryVariables>> = {}) {
return VueApolloComposable.useLazyQuery<LatestSchemaQuery, LatestSchemaQueryVariables>(LatestSchemaDocument, variables, options)
}
export type LatestSchemaQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<LatestSchemaQuery, LatestSchemaQueryVariables>
export const SupergraphDocument = gql`
query Supergraph($ref: String!, $isAfter: String) {
supergraph(ref: $ref, isAfter: $isAfter) {
... on SubGraphs {
id
sdl
subGraphs {
id
service
url
wsUrl
sdl
changedBy
changedAt
}
}
... on Unchanged {
id
minDelaySeconds
}
}
}
`
/**
* __useSupergraphQuery__
*
* To run a query within a Vue component, call `useSupergraphQuery` and pass it any options that fit your needs.
* When your component renders, `useSupergraphQuery` returns an object from Apollo Client that contains result, loading and error properties
* you can use to render your UI.
*
* @param variables that will be passed into the query
* @param options that will be passed into the query, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/query.html#options;
*
* @example
* const { result, loading, error } = useSupergraphQuery({
* ref: // value for 'ref'
* isAfter: // value for 'isAfter'
* });
*/
export function useSupergraphQuery(variables: SupergraphQueryVariables | VueCompositionApi.Ref<SupergraphQueryVariables> | ReactiveFunction<SupergraphQueryVariables>, options: VueApolloComposable.UseQueryOptions<SupergraphQuery, SupergraphQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<SupergraphQuery, SupergraphQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<SupergraphQuery, SupergraphQueryVariables>> = {}) {
return VueApolloComposable.useQuery<SupergraphQuery, SupergraphQueryVariables>(SupergraphDocument, variables, options)
}
export function useSupergraphLazyQuery(variables?: SupergraphQueryVariables | VueCompositionApi.Ref<SupergraphQueryVariables> | ReactiveFunction<SupergraphQueryVariables>, options: VueApolloComposable.UseQueryOptions<SupergraphQuery, SupergraphQueryVariables> | VueCompositionApi.Ref<VueApolloComposable.UseQueryOptions<SupergraphQuery, SupergraphQueryVariables>> | ReactiveFunction<VueApolloComposable.UseQueryOptions<SupergraphQuery, SupergraphQueryVariables>> = {}) {
return VueApolloComposable.useLazyQuery<SupergraphQuery, SupergraphQueryVariables>(SupergraphDocument, variables, options)
}
export type SupergraphQueryCompositionFunctionResult = VueApolloComposable.UseQueryReturn<SupergraphQuery, SupergraphQueryVariables>
export const AddOrganizationDocument = gql`
mutation AddOrganization($name: String!) {
addOrganization(name: $name) {
id
name
users {
id
}
apiKeys {
id
name
refs
read
publish
}
}
}
`
/**
* __useAddOrganizationMutation__
*
* To run a mutation, you first call `useAddOrganizationMutation` within a Vue component and pass it any options that fit your needs.
* When your component renders, `useAddOrganizationMutation` returns an object that includes:
* - A mutate function that you can call at any time to execute the mutation
* - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
*
* @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
*
* @example
* const { mutate, loading, error, onDone } = useAddOrganizationMutation({
* variables: {
* name: // value for 'name'
* },
* });
*/
export function useAddOrganizationMutation(options: VueApolloComposable.UseMutationOptions<AddOrganizationMutation, AddOrganizationMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<AddOrganizationMutation, AddOrganizationMutationVariables>> = {}) {
return VueApolloComposable.useMutation<AddOrganizationMutation, AddOrganizationMutationVariables>(AddOrganizationDocument, options)
}
export type AddOrganizationMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<AddOrganizationMutation, AddOrganizationMutationVariables>
export const AddUserToOrganizationDocument = gql`
mutation AddUserToOrganization($organizationId: ID!, $userId: String!) {
addUserToOrganization(organizationId: $organizationId, userId: $userId) {
id
name
users {
id
}
apiKeys {
id
name
refs
read
publish
}
}
}
`
/**
* __useAddUserToOrganizationMutation__
*
* To run a mutation, you first call `useAddUserToOrganizationMutation` within a Vue component and pass it any options that fit your needs.
* When your component renders, `useAddUserToOrganizationMutation` returns an object that includes:
* - A mutate function that you can call at any time to execute the mutation
* - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
*
* @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
*
* @example
* const { mutate, loading, error, onDone } = useAddUserToOrganizationMutation({
* variables: {
* organizationId: // value for 'organizationId'
* userId: // value for 'userId'
* },
* });
*/
export function useAddUserToOrganizationMutation(options: VueApolloComposable.UseMutationOptions<AddUserToOrganizationMutation, AddUserToOrganizationMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<AddUserToOrganizationMutation, AddUserToOrganizationMutationVariables>> = {}) {
return VueApolloComposable.useMutation<AddUserToOrganizationMutation, AddUserToOrganizationMutationVariables>(AddUserToOrganizationDocument, options)
}
export type AddUserToOrganizationMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<AddUserToOrganizationMutation, AddUserToOrganizationMutationVariables>
export const AddApiKeyDocument = gql`
mutation AddAPIKey($input: InputAPIKey!) {
addAPIKey(input: $input) {
id
name
key
organization {
id
name
}
refs
read
publish
}
}
`
/**
* __useAddApiKeyMutation__
*
* To run a mutation, you first call `useAddApiKeyMutation` within a Vue component and pass it any options that fit your needs.
* When your component renders, `useAddApiKeyMutation` returns an object that includes:
* - A mutate function that you can call at any time to execute the mutation
* - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
*
* @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
*
* @example
* const { mutate, loading, error, onDone } = useAddApiKeyMutation({
* variables: {
* input: // value for 'input'
* },
* });
*/
export function useAddApiKeyMutation(options: VueApolloComposable.UseMutationOptions<AddApiKeyMutation, AddApiKeyMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<AddApiKeyMutation, AddApiKeyMutationVariables>> = {}) {
return VueApolloComposable.useMutation<AddApiKeyMutation, AddApiKeyMutationVariables>(AddApiKeyDocument, options)
}
export type AddApiKeyMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<AddApiKeyMutation, AddApiKeyMutationVariables>
export const RemoveApiKeyDocument = gql`
mutation RemoveAPIKey($organizationId: ID!, $keyName: String!) {
removeAPIKey(organizationId: $organizationId, keyName: $keyName) {
id
name
users {
id
}
apiKeys {
id
name
refs
read
publish
}
}
}
`
/**
* __useRemoveApiKeyMutation__
*
* To run a mutation, you first call `useRemoveApiKeyMutation` within a Vue component and pass it any options that fit your needs.
* When your component renders, `useRemoveApiKeyMutation` returns an object that includes:
* - A mutate function that you can call at any time to execute the mutation
* - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
*
* @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
*
* @example
* const { mutate, loading, error, onDone } = useRemoveApiKeyMutation({
* variables: {
* organizationId: // value for 'organizationId'
* keyName: // value for 'keyName'
* },
* });
*/
export function useRemoveApiKeyMutation(options: VueApolloComposable.UseMutationOptions<RemoveApiKeyMutation, RemoveApiKeyMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<RemoveApiKeyMutation, RemoveApiKeyMutationVariables>> = {}) {
return VueApolloComposable.useMutation<RemoveApiKeyMutation, RemoveApiKeyMutationVariables>(RemoveApiKeyDocument, options)
}
export type RemoveApiKeyMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<RemoveApiKeyMutation, RemoveApiKeyMutationVariables>
export const RemoveOrganizationDocument = gql`
mutation RemoveOrganization($organizationId: ID!) {
removeOrganization(organizationId: $organizationId)
}
`
/**
* __useRemoveOrganizationMutation__
*
* To run a mutation, you first call `useRemoveOrganizationMutation` within a Vue component and pass it any options that fit your needs.
* When your component renders, `useRemoveOrganizationMutation` returns an object that includes:
* - A mutate function that you can call at any time to execute the mutation
* - Several other properties: https://v4.apollo.vuejs.org/api/use-mutation.html#return
*
* @param options that will be passed into the mutation, supported options are listed on: https://v4.apollo.vuejs.org/guide-composable/mutation.html#options;
*
* @example
* const { mutate, loading, error, onDone } = useRemoveOrganizationMutation({
* variables: {
* organizationId: // value for 'organizationId'
* },
* });
*/
export function useRemoveOrganizationMutation(options: VueApolloComposable.UseMutationOptions<RemoveOrganizationMutation, RemoveOrganizationMutationVariables> | ReactiveFunction<VueApolloComposable.UseMutationOptions<RemoveOrganizationMutation, RemoveOrganizationMutationVariables>> = {}) {
return VueApolloComposable.useMutation<RemoveOrganizationMutation, RemoveOrganizationMutationVariables>(RemoveOrganizationDocument, options)
}
export type RemoveOrganizationMutationCompositionFunctionResult = VueApolloComposable.UseMutationReturn<RemoveOrganizationMutation, RemoveOrganizationMutationVariables>