@burdenoff/microfe-integrations 2026.510.111
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +35 -0
- package/dist/dev/main.d.ts +2 -0
- package/dist/dev/main.d.ts.map +1 -0
- package/dist/generated/global-operations.d.ts +2 -0
- package/dist/generated/global-operations.d.ts.map +1 -0
- package/dist/generated/global-types.d.ts +20716 -0
- package/dist/generated/global-types.d.ts.map +1 -0
- package/dist/generated/wspace-operations.d.ts +1645 -0
- package/dist/generated/wspace-operations.d.ts.map +1 -0
- package/dist/generated/wspace-operations.js +561 -0
- package/dist/generated/wspace-operations.js.map +1 -0
- package/dist/generated/wspace-types.d.ts +53434 -0
- package/dist/generated/wspace-types.d.ts.map +1 -0
- package/dist/index.d.ts +6 -0
- package/dist/index.d.ts.map +1 -0
- package/dist/index.js +8 -0
- package/dist/integrations/IntegrationsAdminRoot.d.ts +19 -0
- package/dist/integrations/IntegrationsAdminRoot.d.ts.map +1 -0
- package/dist/integrations/IntegrationsAdminRoot.js +50 -0
- package/dist/integrations/IntegrationsAdminRoot.js.map +1 -0
- package/dist/integrations/IntegrationsAdminRoutes.d.ts +8 -0
- package/dist/integrations/IntegrationsAdminRoutes.d.ts.map +1 -0
- package/dist/integrations/IntegrationsAdminRoutes.js +110 -0
- package/dist/integrations/IntegrationsAdminRoutes.js.map +1 -0
- package/dist/integrations/IntegrationsRoot.d.ts +33 -0
- package/dist/integrations/IntegrationsRoot.d.ts.map +1 -0
- package/dist/integrations/IntegrationsRoot.js +78 -0
- package/dist/integrations/IntegrationsRoot.js.map +1 -0
- package/dist/integrations/IntegrationsRoutes.d.ts +17 -0
- package/dist/integrations/IntegrationsRoutes.d.ts.map +1 -0
- package/dist/integrations/IntegrationsUserRoutes.d.ts +8 -0
- package/dist/integrations/IntegrationsUserRoutes.d.ts.map +1 -0
- package/dist/integrations/IntegrationsUserRoutes.js +116 -0
- package/dist/integrations/IntegrationsUserRoutes.js.map +1 -0
- package/dist/integrations/components/AddConnectionDialog.d.ts +22 -0
- package/dist/integrations/components/AddConnectionDialog.d.ts.map +1 -0
- package/dist/integrations/components/AddConnectionDialog.js +655 -0
- package/dist/integrations/components/AddConnectionDialog.js.map +1 -0
- package/dist/integrations/components/ConfirmDialog.d.ts +17 -0
- package/dist/integrations/components/ConfirmDialog.d.ts.map +1 -0
- package/dist/integrations/components/ConfirmDialog.js +55 -0
- package/dist/integrations/components/ConfirmDialog.js.map +1 -0
- package/dist/integrations/components/ConnectionCard.d.ts +14 -0
- package/dist/integrations/components/ConnectionCard.d.ts.map +1 -0
- package/dist/integrations/components/ConnectionCard.js +101 -0
- package/dist/integrations/components/ConnectionCard.js.map +1 -0
- package/dist/integrations/components/ConnectionStatusBadge.d.ts +14 -0
- package/dist/integrations/components/ConnectionStatusBadge.d.ts.map +1 -0
- package/dist/integrations/components/ConnectionStatusBadge.js +12 -0
- package/dist/integrations/components/ConnectionStatusBadge.js.map +1 -0
- package/dist/integrations/components/CredentialStorageSelector.d.ts +16 -0
- package/dist/integrations/components/CredentialStorageSelector.d.ts.map +1 -0
- package/dist/integrations/components/CredentialStorageSelector.js +159 -0
- package/dist/integrations/components/CredentialStorageSelector.js.map +1 -0
- package/dist/integrations/components/ProviderCard.d.ts +16 -0
- package/dist/integrations/components/ProviderCard.d.ts.map +1 -0
- package/dist/integrations/components/ProviderCard.js +161 -0
- package/dist/integrations/components/ProviderCard.js.map +1 -0
- package/dist/integrations/components/ProviderIcon.d.ts +19 -0
- package/dist/integrations/components/ProviderIcon.d.ts.map +1 -0
- package/dist/integrations/components/ProviderIcon.js +92 -0
- package/dist/integrations/components/ProviderIcon.js.map +1 -0
- package/dist/integrations/components/ui.d.ts +6 -0
- package/dist/integrations/components/ui.d.ts.map +1 -0
- package/dist/integrations/constants/enums.d.ts +70 -0
- package/dist/integrations/constants/enums.d.ts.map +1 -0
- package/dist/integrations/constants/featureFlags.d.ts +7 -0
- package/dist/integrations/constants/featureFlags.d.ts.map +1 -0
- package/dist/integrations/constants/featureFlags.js +11 -0
- package/dist/integrations/constants/featureFlags.js.map +1 -0
- package/dist/integrations/constants/permissions.d.ts +22 -0
- package/dist/integrations/constants/permissions.d.ts.map +1 -0
- package/dist/integrations/constants/permissions.js +20 -0
- package/dist/integrations/constants/permissions.js.map +1 -0
- package/dist/integrations/events/integrations-events.d.ts +36 -0
- package/dist/integrations/events/integrations-events.d.ts.map +1 -0
- package/dist/integrations/events/useIntegrationsEventBus.d.ts +11 -0
- package/dist/integrations/events/useIntegrationsEventBus.d.ts.map +1 -0
- package/dist/integrations/events/useIntegrationsEventBus.js +23 -0
- package/dist/integrations/events/useIntegrationsEventBus.js.map +1 -0
- package/dist/integrations/hooks/useConnections.d.ts +84 -0
- package/dist/integrations/hooks/useConnections.d.ts.map +1 -0
- package/dist/integrations/hooks/useConnections.js +162 -0
- package/dist/integrations/hooks/useConnections.js.map +1 -0
- package/dist/integrations/hooks/useCredentialVaults.d.ts +15 -0
- package/dist/integrations/hooks/useCredentialVaults.d.ts.map +1 -0
- package/dist/integrations/hooks/useCredentialVaults.js +77 -0
- package/dist/integrations/hooks/useCredentialVaults.js.map +1 -0
- package/dist/integrations/hooks/useLogs.d.ts +27 -0
- package/dist/integrations/hooks/useLogs.d.ts.map +1 -0
- package/dist/integrations/hooks/useLogs.js +32 -0
- package/dist/integrations/hooks/useLogs.js.map +1 -0
- package/dist/integrations/hooks/useProviders.d.ts +97 -0
- package/dist/integrations/hooks/useProviders.d.ts.map +1 -0
- package/dist/integrations/hooks/useProviders.js +102 -0
- package/dist/integrations/hooks/useProviders.js.map +1 -0
- package/dist/integrations/index.d.ts +33 -0
- package/dist/integrations/index.d.ts.map +1 -0
- package/dist/integrations/index.js +6 -0
- package/dist/integrations/pages/AddConnectionWizard.d.ts +14 -0
- package/dist/integrations/pages/AddConnectionWizard.d.ts.map +1 -0
- package/dist/integrations/pages/AddConnectionWizard.js +635 -0
- package/dist/integrations/pages/AddConnectionWizard.js.map +1 -0
- package/dist/integrations/pages/ConnectionDetail.d.ts +5 -0
- package/dist/integrations/pages/ConnectionDetail.d.ts.map +1 -0
- package/dist/integrations/pages/ConnectionDetail.js +469 -0
- package/dist/integrations/pages/ConnectionDetail.js.map +1 -0
- package/dist/integrations/pages/ConnectionLogs.d.ts +5 -0
- package/dist/integrations/pages/ConnectionLogs.d.ts.map +1 -0
- package/dist/integrations/pages/ConnectionLogs.js +394 -0
- package/dist/integrations/pages/ConnectionLogs.js.map +1 -0
- package/dist/integrations/pages/ConnectionsList.d.ts +5 -0
- package/dist/integrations/pages/ConnectionsList.d.ts.map +1 -0
- package/dist/integrations/pages/ConnectionsList.js +258 -0
- package/dist/integrations/pages/ConnectionsList.js.map +1 -0
- package/dist/integrations/pages/IntegrationsAdminLandingPage.d.ts +11 -0
- package/dist/integrations/pages/IntegrationsAdminLandingPage.d.ts.map +1 -0
- package/dist/integrations/pages/IntegrationsLandingPage.d.ts +9 -0
- package/dist/integrations/pages/IntegrationsLandingPage.d.ts.map +1 -0
- package/dist/integrations/pages/IntegrationsOverview.d.ts +5 -0
- package/dist/integrations/pages/IntegrationsOverview.d.ts.map +1 -0
- package/dist/integrations/pages/IntegrationsOverview.js +432 -0
- package/dist/integrations/pages/IntegrationsOverview.js.map +1 -0
- package/dist/integrations/pages/IntegrationsSettings.d.ts +5 -0
- package/dist/integrations/pages/IntegrationsSettings.d.ts.map +1 -0
- package/dist/integrations/pages/IntegrationsSettings.js +222 -0
- package/dist/integrations/pages/IntegrationsSettings.js.map +1 -0
- package/dist/integrations/pages/IntegrationsUserLandingPage.d.ts +11 -0
- package/dist/integrations/pages/IntegrationsUserLandingPage.d.ts.map +1 -0
- package/dist/integrations/pages/IntegrationsUserLandingPage.js +56 -0
- package/dist/integrations/pages/IntegrationsUserLandingPage.js.map +1 -0
- package/dist/integrations/pages/ProviderCatalog.d.ts +9 -0
- package/dist/integrations/pages/ProviderCatalog.d.ts.map +1 -0
- package/dist/integrations/pages/ProviderCatalog.js +337 -0
- package/dist/integrations/pages/ProviderCatalog.js.map +1 -0
- package/dist/integrations/pages/ProviderDetail.d.ts +5 -0
- package/dist/integrations/pages/ProviderDetail.d.ts.map +1 -0
- package/dist/integrations/pages/ProviderDetail.js +386 -0
- package/dist/integrations/pages/ProviderDetail.js.map +1 -0
- package/dist/integrations/pages/ProviderEditorPage.d.ts +2 -0
- package/dist/integrations/pages/ProviderEditorPage.d.ts.map +1 -0
- package/dist/integrations/pages/ProviderEditorPage.js +412 -0
- package/dist/integrations/pages/ProviderEditorPage.js.map +1 -0
- package/dist/integrations/providers/IntegrationsProvider.d.ts +13 -0
- package/dist/integrations/providers/IntegrationsProvider.d.ts.map +1 -0
- package/dist/integrations/providers/IntegrationsProvider.js +121 -0
- package/dist/integrations/providers/IntegrationsProvider.js.map +1 -0
- package/dist/integrations/store/integrationsStore.d.ts +21 -0
- package/dist/integrations/store/integrationsStore.d.ts.map +1 -0
- package/dist/integrations/store/integrationsStore.js +43 -0
- package/dist/integrations/store/integrationsStore.js.map +1 -0
- package/dist/integrations/types/index.d.ts +217 -0
- package/dist/integrations/types/index.d.ts.map +1 -0
- package/dist/integrations/utils/appearance.d.ts +14 -0
- package/dist/integrations/utils/appearance.d.ts.map +1 -0
- package/dist/integrations/utils/appearance.js +64 -0
- package/dist/integrations/utils/appearance.js.map +1 -0
- package/dist/integrations/utils/cn.d.ts +8 -0
- package/dist/integrations/utils/cn.d.ts.map +1 -0
- package/dist/integrations/utils/cn.js +10 -0
- package/dist/integrations/utils/cn.js.map +1 -0
- package/dist/integrations/utils/constants.d.ts +194 -0
- package/dist/integrations/utils/constants.d.ts.map +1 -0
- package/dist/integrations/utils/constants.js +200 -0
- package/dist/integrations/utils/constants.js.map +1 -0
- package/dist/integrations/utils/i18n.d.ts +6 -0
- package/dist/integrations/utils/i18n.d.ts.map +1 -0
- package/dist/integrations/utils/integrationsHelpers.d.ts +39 -0
- package/dist/integrations/utils/integrationsHelpers.d.ts.map +1 -0
- package/dist/integrations/utils/integrationsHelpers.js +82 -0
- package/dist/integrations/utils/integrationsHelpers.js.map +1 -0
- package/dist/integrations/utils/mappers.d.ts +15 -0
- package/dist/integrations/utils/mappers.d.ts.map +1 -0
- package/dist/integrations/utils/mappers.js +151 -0
- package/dist/integrations/utils/mappers.js.map +1 -0
- package/dist/integrations/utils/navigation.d.ts +18 -0
- package/dist/integrations/utils/navigation.d.ts.map +1 -0
- package/dist/integrations/utils/navigation.js +13 -0
- package/dist/integrations/utils/navigation.js.map +1 -0
- package/dist/integrations/utils/oauthPopup.d.ts +16 -0
- package/dist/integrations/utils/oauthPopup.d.ts.map +1 -0
- package/dist/integrations/utils/oauthPopup.js +62 -0
- package/dist/integrations/utils/oauthPopup.js.map +1 -0
- package/dist/integrations/utils/paths.d.ts +5 -0
- package/dist/integrations/utils/paths.d.ts.map +1 -0
- package/dist/integrations/utils/paths.js +6 -0
- package/dist/integrations/utils/paths.js.map +1 -0
- package/dist/node_modules/@iconify/react/dist/iconify.js +1005 -0
- package/dist/node_modules/@iconify/react/dist/iconify.js.map +1 -0
- package/dist/node_modules/clsx/dist/clsx.js +18 -0
- package/dist/node_modules/clsx/dist/clsx.js.map +1 -0
- package/dist/node_modules/tailwind-merge/dist/bundle-mjs.js +1674 -0
- package/dist/node_modules/tailwind-merge/dist/bundle-mjs.js.map +1 -0
- package/dist/utils/nativeBridge.d.ts +3 -0
- package/dist/utils/nativeBridge.d.ts.map +1 -0
- package/dist/utils/nativeBridge.js +2 -0
- package/package.json +107 -0
|
@@ -0,0 +1,1645 @@
|
|
|
1
|
+
import * as Types from './wspace-types';
|
|
2
|
+
import * as Apollo from '@apollo/client';
|
|
3
|
+
import * as ApolloReactHooks from '@apollo/client/react';
|
|
4
|
+
export type IntegrationConnectionFieldsFragment = {
|
|
5
|
+
__typename?: 'IntegrationConnection';
|
|
6
|
+
id: string;
|
|
7
|
+
name: string;
|
|
8
|
+
description?: string | null;
|
|
9
|
+
status: Types.ConnectionStatus;
|
|
10
|
+
lastHealthCheck?: string | null;
|
|
11
|
+
lastUsedAt?: string | null;
|
|
12
|
+
errorMessage?: string | null;
|
|
13
|
+
externalAccountId?: string | null;
|
|
14
|
+
externalAccountEmail?: string | null;
|
|
15
|
+
externalAccountName?: string | null;
|
|
16
|
+
grantedScopes: Array<string>;
|
|
17
|
+
config?: Record<string, unknown> | null;
|
|
18
|
+
metadata?: Record<string, unknown> | null;
|
|
19
|
+
createdBy: string;
|
|
20
|
+
createdAt: string;
|
|
21
|
+
updatedAt: string;
|
|
22
|
+
provider: {
|
|
23
|
+
__typename?: 'IntegrationProvider';
|
|
24
|
+
id: string;
|
|
25
|
+
key: string;
|
|
26
|
+
name: string;
|
|
27
|
+
description?: string | null;
|
|
28
|
+
category: Types.ProviderCategory;
|
|
29
|
+
authType: Types.AuthType;
|
|
30
|
+
icon?: string | null;
|
|
31
|
+
color?: string | null;
|
|
32
|
+
pluginStatus: Types.PluginStatus;
|
|
33
|
+
isEnabled: boolean;
|
|
34
|
+
connectionCount: number;
|
|
35
|
+
};
|
|
36
|
+
tagAssignments: Array<{
|
|
37
|
+
__typename?: 'IntegrationConnectionTagAssignment';
|
|
38
|
+
id: string;
|
|
39
|
+
tagId: string;
|
|
40
|
+
entityType: string;
|
|
41
|
+
entityId: string;
|
|
42
|
+
source: string;
|
|
43
|
+
assignedBy?: string | null;
|
|
44
|
+
assignedAt?: string | null;
|
|
45
|
+
tag?: {
|
|
46
|
+
__typename?: 'UniversalTag';
|
|
47
|
+
id: string;
|
|
48
|
+
} | null;
|
|
49
|
+
}>;
|
|
50
|
+
};
|
|
51
|
+
export type IntegrationConnectionSummaryFieldsFragment = {
|
|
52
|
+
__typename?: 'IntegrationConnection';
|
|
53
|
+
id: string;
|
|
54
|
+
name: string;
|
|
55
|
+
description?: string | null;
|
|
56
|
+
status: Types.ConnectionStatus;
|
|
57
|
+
lastHealthCheck?: string | null;
|
|
58
|
+
lastUsedAt?: string | null;
|
|
59
|
+
errorMessage?: string | null;
|
|
60
|
+
externalAccountId?: string | null;
|
|
61
|
+
externalAccountEmail?: string | null;
|
|
62
|
+
externalAccountName?: string | null;
|
|
63
|
+
grantedScopes: Array<string>;
|
|
64
|
+
createdBy: string;
|
|
65
|
+
createdAt: string;
|
|
66
|
+
updatedAt: string;
|
|
67
|
+
provider: {
|
|
68
|
+
__typename?: 'IntegrationProvider';
|
|
69
|
+
id: string;
|
|
70
|
+
key: string;
|
|
71
|
+
name: string;
|
|
72
|
+
description?: string | null;
|
|
73
|
+
category: Types.ProviderCategory;
|
|
74
|
+
authType: Types.AuthType;
|
|
75
|
+
icon?: string | null;
|
|
76
|
+
color?: string | null;
|
|
77
|
+
pluginStatus: Types.PluginStatus;
|
|
78
|
+
isEnabled: boolean;
|
|
79
|
+
connectionCount: number;
|
|
80
|
+
};
|
|
81
|
+
};
|
|
82
|
+
export type IntegrationLogFieldsFragment = {
|
|
83
|
+
__typename?: 'IntegrationLog';
|
|
84
|
+
id: string;
|
|
85
|
+
connectionId?: string | null;
|
|
86
|
+
action: Types.LogAction;
|
|
87
|
+
level: Types.LogLevel;
|
|
88
|
+
message: string;
|
|
89
|
+
requestUrl?: string | null;
|
|
90
|
+
requestMethod?: string | null;
|
|
91
|
+
responseStatus?: number | null;
|
|
92
|
+
metadata?: Record<string, unknown> | null;
|
|
93
|
+
createdAt: string;
|
|
94
|
+
};
|
|
95
|
+
export type IntegrationProviderFieldsFragment = {
|
|
96
|
+
__typename?: 'IntegrationProvider';
|
|
97
|
+
id: string;
|
|
98
|
+
key: string;
|
|
99
|
+
name: string;
|
|
100
|
+
description?: string | null;
|
|
101
|
+
category: Types.ProviderCategory;
|
|
102
|
+
authType: Types.AuthType;
|
|
103
|
+
icon?: string | null;
|
|
104
|
+
color?: string | null;
|
|
105
|
+
website?: string | null;
|
|
106
|
+
docsUrl?: string | null;
|
|
107
|
+
oauthConfig?: Record<string, unknown> | null;
|
|
108
|
+
defaultScopes: Array<string>;
|
|
109
|
+
availableScopes?: Record<string, unknown> | null;
|
|
110
|
+
baseUrl?: string | null;
|
|
111
|
+
apiVersion?: string | null;
|
|
112
|
+
rateLimitConfig?: Record<string, unknown> | null;
|
|
113
|
+
pluginStatus: Types.PluginStatus;
|
|
114
|
+
pluginVersion?: string | null;
|
|
115
|
+
pluginAuthor?: string | null;
|
|
116
|
+
pluginRepository?: string | null;
|
|
117
|
+
isBuiltIn: boolean;
|
|
118
|
+
isEnabled: boolean;
|
|
119
|
+
displayOrder: number;
|
|
120
|
+
supportedFeatures: Array<string>;
|
|
121
|
+
configSchema?: Record<string, unknown> | null;
|
|
122
|
+
connectionCount: number;
|
|
123
|
+
createdAt: string;
|
|
124
|
+
updatedAt: string;
|
|
125
|
+
};
|
|
126
|
+
export type IntegrationProviderSummaryFieldsFragment = {
|
|
127
|
+
__typename?: 'IntegrationProvider';
|
|
128
|
+
id: string;
|
|
129
|
+
key: string;
|
|
130
|
+
name: string;
|
|
131
|
+
description?: string | null;
|
|
132
|
+
category: Types.ProviderCategory;
|
|
133
|
+
authType: Types.AuthType;
|
|
134
|
+
icon?: string | null;
|
|
135
|
+
color?: string | null;
|
|
136
|
+
pluginStatus: Types.PluginStatus;
|
|
137
|
+
isEnabled: boolean;
|
|
138
|
+
connectionCount: number;
|
|
139
|
+
};
|
|
140
|
+
export type IntegrationConnectionTagAssignmentFieldsFragment = {
|
|
141
|
+
__typename?: 'IntegrationConnectionTagAssignment';
|
|
142
|
+
id: string;
|
|
143
|
+
tagId: string;
|
|
144
|
+
entityType: string;
|
|
145
|
+
entityId: string;
|
|
146
|
+
source: string;
|
|
147
|
+
assignedBy?: string | null;
|
|
148
|
+
assignedAt?: string | null;
|
|
149
|
+
tag?: {
|
|
150
|
+
__typename?: 'UniversalTag';
|
|
151
|
+
id: string;
|
|
152
|
+
} | null;
|
|
153
|
+
};
|
|
154
|
+
export type AuthenticateWithApiKeyMutationVariables = Types.Exact<{
|
|
155
|
+
input: Types.ApiKeyAuthInput;
|
|
156
|
+
}>;
|
|
157
|
+
export type AuthenticateWithApiKeyMutation = {
|
|
158
|
+
__typename?: 'Mutation';
|
|
159
|
+
authenticateWithApiKey: {
|
|
160
|
+
__typename?: 'IntegrationConnection';
|
|
161
|
+
id: string;
|
|
162
|
+
status: Types.ConnectionStatus;
|
|
163
|
+
};
|
|
164
|
+
};
|
|
165
|
+
export type AuthenticateWithBasicAuthMutationVariables = Types.Exact<{
|
|
166
|
+
input: Types.BasicAuthInput;
|
|
167
|
+
}>;
|
|
168
|
+
export type AuthenticateWithBasicAuthMutation = {
|
|
169
|
+
__typename?: 'Mutation';
|
|
170
|
+
authenticateWithBasicAuth: {
|
|
171
|
+
__typename?: 'IntegrationConnection';
|
|
172
|
+
id: string;
|
|
173
|
+
status: Types.ConnectionStatus;
|
|
174
|
+
};
|
|
175
|
+
};
|
|
176
|
+
export type AuthenticateWithBearerTokenMutationVariables = Types.Exact<{
|
|
177
|
+
input: Types.BearerTokenAuthInput;
|
|
178
|
+
}>;
|
|
179
|
+
export type AuthenticateWithBearerTokenMutation = {
|
|
180
|
+
__typename?: 'Mutation';
|
|
181
|
+
authenticateWithBearerToken: {
|
|
182
|
+
__typename?: 'IntegrationConnection';
|
|
183
|
+
id: string;
|
|
184
|
+
status: Types.ConnectionStatus;
|
|
185
|
+
};
|
|
186
|
+
};
|
|
187
|
+
export type CompleteOAuthMutationVariables = Types.Exact<{
|
|
188
|
+
input: Types.CompleteOAuthInput;
|
|
189
|
+
}>;
|
|
190
|
+
export type CompleteOAuthMutation = {
|
|
191
|
+
__typename?: 'Mutation';
|
|
192
|
+
completeOAuth: {
|
|
193
|
+
__typename?: 'IntegrationConnection';
|
|
194
|
+
id: string;
|
|
195
|
+
status: Types.ConnectionStatus;
|
|
196
|
+
};
|
|
197
|
+
};
|
|
198
|
+
export type CreateConnectionMutationVariables = Types.Exact<{
|
|
199
|
+
input: Types.CreateConnectionInput;
|
|
200
|
+
}>;
|
|
201
|
+
export type CreateConnectionMutation = {
|
|
202
|
+
__typename?: 'Mutation';
|
|
203
|
+
createConnection: {
|
|
204
|
+
__typename?: 'IntegrationConnection';
|
|
205
|
+
id: string;
|
|
206
|
+
name: string;
|
|
207
|
+
description?: string | null;
|
|
208
|
+
status: Types.ConnectionStatus;
|
|
209
|
+
createdAt: string;
|
|
210
|
+
};
|
|
211
|
+
};
|
|
212
|
+
export type DeleteConnectionMutationVariables = Types.Exact<{
|
|
213
|
+
id: Types.Scalars['ID']['input'];
|
|
214
|
+
deleteVaultSecret?: Types.InputMaybe<Types.Scalars['Boolean']['input']>;
|
|
215
|
+
}>;
|
|
216
|
+
export type DeleteConnectionMutation = {
|
|
217
|
+
__typename?: 'Mutation';
|
|
218
|
+
deleteConnection: boolean;
|
|
219
|
+
};
|
|
220
|
+
export type DisableProviderMutationVariables = Types.Exact<{
|
|
221
|
+
id: Types.Scalars['ID']['input'];
|
|
222
|
+
}>;
|
|
223
|
+
export type DisableProviderMutation = {
|
|
224
|
+
__typename?: 'Mutation';
|
|
225
|
+
disableProvider: {
|
|
226
|
+
__typename?: 'IntegrationProvider';
|
|
227
|
+
id: string;
|
|
228
|
+
isEnabled: boolean;
|
|
229
|
+
};
|
|
230
|
+
};
|
|
231
|
+
export type EnableProviderMutationVariables = Types.Exact<{
|
|
232
|
+
id: Types.Scalars['ID']['input'];
|
|
233
|
+
}>;
|
|
234
|
+
export type EnableProviderMutation = {
|
|
235
|
+
__typename?: 'Mutation';
|
|
236
|
+
enableProvider: {
|
|
237
|
+
__typename?: 'IntegrationProvider';
|
|
238
|
+
id: string;
|
|
239
|
+
isEnabled: boolean;
|
|
240
|
+
};
|
|
241
|
+
};
|
|
242
|
+
export type InitiateOAuthMutationVariables = Types.Exact<{
|
|
243
|
+
input: Types.InitiateOAuthInput;
|
|
244
|
+
}>;
|
|
245
|
+
export type InitiateOAuthMutation = {
|
|
246
|
+
__typename?: 'Mutation';
|
|
247
|
+
initiateOAuth: {
|
|
248
|
+
__typename?: 'OAuthInitiationResult';
|
|
249
|
+
redirectUrl: string;
|
|
250
|
+
state: string;
|
|
251
|
+
};
|
|
252
|
+
};
|
|
253
|
+
export type InstallProviderPluginMutationVariables = Types.Exact<{
|
|
254
|
+
input: Types.InstallProviderPluginInput;
|
|
255
|
+
}>;
|
|
256
|
+
export type InstallProviderPluginMutation = {
|
|
257
|
+
__typename?: 'Mutation';
|
|
258
|
+
installProviderPlugin: {
|
|
259
|
+
__typename?: 'IntegrationProvider';
|
|
260
|
+
id: string;
|
|
261
|
+
key: string;
|
|
262
|
+
name: string;
|
|
263
|
+
description?: string | null;
|
|
264
|
+
category: Types.ProviderCategory;
|
|
265
|
+
authType: Types.AuthType;
|
|
266
|
+
icon?: string | null;
|
|
267
|
+
color?: string | null;
|
|
268
|
+
website?: string | null;
|
|
269
|
+
docsUrl?: string | null;
|
|
270
|
+
oauthConfig?: Record<string, unknown> | null;
|
|
271
|
+
defaultScopes: Array<string>;
|
|
272
|
+
availableScopes?: Record<string, unknown> | null;
|
|
273
|
+
baseUrl?: string | null;
|
|
274
|
+
apiVersion?: string | null;
|
|
275
|
+
rateLimitConfig?: Record<string, unknown> | null;
|
|
276
|
+
pluginStatus: Types.PluginStatus;
|
|
277
|
+
pluginVersion?: string | null;
|
|
278
|
+
pluginAuthor?: string | null;
|
|
279
|
+
pluginRepository?: string | null;
|
|
280
|
+
isBuiltIn: boolean;
|
|
281
|
+
isEnabled: boolean;
|
|
282
|
+
displayOrder: number;
|
|
283
|
+
supportedFeatures: Array<string>;
|
|
284
|
+
configSchema?: Record<string, unknown> | null;
|
|
285
|
+
connectionCount: number;
|
|
286
|
+
createdAt: string;
|
|
287
|
+
updatedAt: string;
|
|
288
|
+
};
|
|
289
|
+
};
|
|
290
|
+
export type RefreshConnectionTokenMutationVariables = Types.Exact<{
|
|
291
|
+
connectionId: Types.Scalars['ID']['input'];
|
|
292
|
+
}>;
|
|
293
|
+
export type RefreshConnectionTokenMutation = {
|
|
294
|
+
__typename?: 'Mutation';
|
|
295
|
+
refreshConnectionToken: {
|
|
296
|
+
__typename?: 'IntegrationConnection';
|
|
297
|
+
id: string;
|
|
298
|
+
status: Types.ConnectionStatus;
|
|
299
|
+
};
|
|
300
|
+
};
|
|
301
|
+
export type RevokeConnectionMutationVariables = Types.Exact<{
|
|
302
|
+
connectionId: Types.Scalars['ID']['input'];
|
|
303
|
+
}>;
|
|
304
|
+
export type RevokeConnectionMutation = {
|
|
305
|
+
__typename?: 'Mutation';
|
|
306
|
+
revokeConnection: {
|
|
307
|
+
__typename?: 'IntegrationConnection';
|
|
308
|
+
id: string;
|
|
309
|
+
status: Types.ConnectionStatus;
|
|
310
|
+
};
|
|
311
|
+
};
|
|
312
|
+
export type TagConnectionMutationVariables = Types.Exact<{
|
|
313
|
+
input: Types.TagConnectionInput;
|
|
314
|
+
}>;
|
|
315
|
+
export type TagConnectionMutation = {
|
|
316
|
+
__typename?: 'Mutation';
|
|
317
|
+
tagConnection: {
|
|
318
|
+
__typename?: 'IntegrationConnectionTagAssignment';
|
|
319
|
+
id: string;
|
|
320
|
+
tagId: string;
|
|
321
|
+
entityType: string;
|
|
322
|
+
entityId: string;
|
|
323
|
+
source: string;
|
|
324
|
+
assignedBy?: string | null;
|
|
325
|
+
assignedAt?: string | null;
|
|
326
|
+
tag?: {
|
|
327
|
+
__typename?: 'UniversalTag';
|
|
328
|
+
id: string;
|
|
329
|
+
} | null;
|
|
330
|
+
};
|
|
331
|
+
};
|
|
332
|
+
export type UntagConnectionMutationVariables = Types.Exact<{
|
|
333
|
+
input: Types.UntagConnectionInput;
|
|
334
|
+
}>;
|
|
335
|
+
export type UntagConnectionMutation = {
|
|
336
|
+
__typename?: 'Mutation';
|
|
337
|
+
untagConnection: boolean;
|
|
338
|
+
};
|
|
339
|
+
export type ReplaceConnectionTagsMutationVariables = Types.Exact<{
|
|
340
|
+
input: Types.ReplaceConnectionTagsInput;
|
|
341
|
+
}>;
|
|
342
|
+
export type ReplaceConnectionTagsMutation = {
|
|
343
|
+
__typename?: 'Mutation';
|
|
344
|
+
replaceConnectionTags: Array<{
|
|
345
|
+
__typename?: 'IntegrationConnectionTagAssignment';
|
|
346
|
+
id: string;
|
|
347
|
+
tagId: string;
|
|
348
|
+
entityType: string;
|
|
349
|
+
entityId: string;
|
|
350
|
+
source: string;
|
|
351
|
+
assignedBy?: string | null;
|
|
352
|
+
assignedAt?: string | null;
|
|
353
|
+
tag?: {
|
|
354
|
+
__typename?: 'UniversalTag';
|
|
355
|
+
id: string;
|
|
356
|
+
} | null;
|
|
357
|
+
}>;
|
|
358
|
+
};
|
|
359
|
+
export type TestConnectionMutationVariables = Types.Exact<{
|
|
360
|
+
connectionId: Types.Scalars['ID']['input'];
|
|
361
|
+
}>;
|
|
362
|
+
export type TestConnectionMutation = {
|
|
363
|
+
__typename?: 'Mutation';
|
|
364
|
+
testConnection: {
|
|
365
|
+
__typename?: 'ConnectionTestResult';
|
|
366
|
+
success: boolean;
|
|
367
|
+
message: string;
|
|
368
|
+
latencyMs?: number | null;
|
|
369
|
+
};
|
|
370
|
+
};
|
|
371
|
+
export type UninstallProviderPluginMutationVariables = Types.Exact<{
|
|
372
|
+
id: Types.Scalars['ID']['input'];
|
|
373
|
+
}>;
|
|
374
|
+
export type UninstallProviderPluginMutation = {
|
|
375
|
+
__typename?: 'Mutation';
|
|
376
|
+
uninstallProviderPlugin: boolean;
|
|
377
|
+
};
|
|
378
|
+
export type UpdateConnectionMutationVariables = Types.Exact<{
|
|
379
|
+
id: Types.Scalars['ID']['input'];
|
|
380
|
+
input: Types.UpdateConnectionInput;
|
|
381
|
+
}>;
|
|
382
|
+
export type UpdateConnectionMutation = {
|
|
383
|
+
__typename?: 'Mutation';
|
|
384
|
+
updateConnection: {
|
|
385
|
+
__typename?: 'IntegrationConnection';
|
|
386
|
+
id: string;
|
|
387
|
+
name: string;
|
|
388
|
+
description?: string | null;
|
|
389
|
+
};
|
|
390
|
+
};
|
|
391
|
+
export type UpdateProviderPluginMutationVariables = Types.Exact<{
|
|
392
|
+
id: Types.Scalars['ID']['input'];
|
|
393
|
+
input: Types.UpdateProviderPluginInput;
|
|
394
|
+
}>;
|
|
395
|
+
export type UpdateProviderPluginMutation = {
|
|
396
|
+
__typename?: 'Mutation';
|
|
397
|
+
updateProviderPlugin: {
|
|
398
|
+
__typename?: 'IntegrationProvider';
|
|
399
|
+
id: string;
|
|
400
|
+
key: string;
|
|
401
|
+
name: string;
|
|
402
|
+
description?: string | null;
|
|
403
|
+
category: Types.ProviderCategory;
|
|
404
|
+
authType: Types.AuthType;
|
|
405
|
+
icon?: string | null;
|
|
406
|
+
color?: string | null;
|
|
407
|
+
website?: string | null;
|
|
408
|
+
docsUrl?: string | null;
|
|
409
|
+
oauthConfig?: Record<string, unknown> | null;
|
|
410
|
+
defaultScopes: Array<string>;
|
|
411
|
+
availableScopes?: Record<string, unknown> | null;
|
|
412
|
+
baseUrl?: string | null;
|
|
413
|
+
apiVersion?: string | null;
|
|
414
|
+
rateLimitConfig?: Record<string, unknown> | null;
|
|
415
|
+
pluginStatus: Types.PluginStatus;
|
|
416
|
+
pluginVersion?: string | null;
|
|
417
|
+
pluginAuthor?: string | null;
|
|
418
|
+
pluginRepository?: string | null;
|
|
419
|
+
isBuiltIn: boolean;
|
|
420
|
+
isEnabled: boolean;
|
|
421
|
+
displayOrder: number;
|
|
422
|
+
supportedFeatures: Array<string>;
|
|
423
|
+
configSchema?: Record<string, unknown> | null;
|
|
424
|
+
connectionCount: number;
|
|
425
|
+
createdAt: string;
|
|
426
|
+
updatedAt: string;
|
|
427
|
+
};
|
|
428
|
+
};
|
|
429
|
+
export type GetConnectionQueryVariables = Types.Exact<{
|
|
430
|
+
id: Types.Scalars['ID']['input'];
|
|
431
|
+
}>;
|
|
432
|
+
export type GetConnectionQuery = {
|
|
433
|
+
__typename?: 'Query';
|
|
434
|
+
getConnection?: {
|
|
435
|
+
__typename?: 'IntegrationConnection';
|
|
436
|
+
id: string;
|
|
437
|
+
name: string;
|
|
438
|
+
description?: string | null;
|
|
439
|
+
status: Types.ConnectionStatus;
|
|
440
|
+
lastHealthCheck?: string | null;
|
|
441
|
+
lastUsedAt?: string | null;
|
|
442
|
+
errorMessage?: string | null;
|
|
443
|
+
externalAccountId?: string | null;
|
|
444
|
+
externalAccountEmail?: string | null;
|
|
445
|
+
externalAccountName?: string | null;
|
|
446
|
+
grantedScopes: Array<string>;
|
|
447
|
+
config?: Record<string, unknown> | null;
|
|
448
|
+
metadata?: Record<string, unknown> | null;
|
|
449
|
+
createdBy: string;
|
|
450
|
+
createdAt: string;
|
|
451
|
+
updatedAt: string;
|
|
452
|
+
provider: {
|
|
453
|
+
__typename?: 'IntegrationProvider';
|
|
454
|
+
id: string;
|
|
455
|
+
key: string;
|
|
456
|
+
name: string;
|
|
457
|
+
description?: string | null;
|
|
458
|
+
category: Types.ProviderCategory;
|
|
459
|
+
authType: Types.AuthType;
|
|
460
|
+
icon?: string | null;
|
|
461
|
+
color?: string | null;
|
|
462
|
+
pluginStatus: Types.PluginStatus;
|
|
463
|
+
isEnabled: boolean;
|
|
464
|
+
connectionCount: number;
|
|
465
|
+
};
|
|
466
|
+
tagAssignments: Array<{
|
|
467
|
+
__typename?: 'IntegrationConnectionTagAssignment';
|
|
468
|
+
id: string;
|
|
469
|
+
tagId: string;
|
|
470
|
+
entityType: string;
|
|
471
|
+
entityId: string;
|
|
472
|
+
source: string;
|
|
473
|
+
assignedBy?: string | null;
|
|
474
|
+
assignedAt?: string | null;
|
|
475
|
+
tag?: {
|
|
476
|
+
__typename?: 'UniversalTag';
|
|
477
|
+
id: string;
|
|
478
|
+
} | null;
|
|
479
|
+
}>;
|
|
480
|
+
} | null;
|
|
481
|
+
};
|
|
482
|
+
export type GetConnectionLogsQueryVariables = Types.Exact<{
|
|
483
|
+
connectionId: Types.Scalars['ID']['input'];
|
|
484
|
+
filter?: Types.InputMaybe<Types.LogFilterInput>;
|
|
485
|
+
pagination?: Types.InputMaybe<Types.IntegrationsPaginationInput>;
|
|
486
|
+
}>;
|
|
487
|
+
export type GetConnectionLogsQuery = {
|
|
488
|
+
__typename?: 'Query';
|
|
489
|
+
getConnectionLogs: {
|
|
490
|
+
__typename?: 'LogList';
|
|
491
|
+
total: number;
|
|
492
|
+
hasMore: boolean;
|
|
493
|
+
items: Array<{
|
|
494
|
+
__typename?: 'IntegrationLog';
|
|
495
|
+
id: string;
|
|
496
|
+
connectionId?: string | null;
|
|
497
|
+
action: Types.LogAction;
|
|
498
|
+
level: Types.LogLevel;
|
|
499
|
+
message: string;
|
|
500
|
+
requestUrl?: string | null;
|
|
501
|
+
requestMethod?: string | null;
|
|
502
|
+
responseStatus?: number | null;
|
|
503
|
+
metadata?: Record<string, unknown> | null;
|
|
504
|
+
createdAt: string;
|
|
505
|
+
}>;
|
|
506
|
+
};
|
|
507
|
+
};
|
|
508
|
+
export type GetConnectionTagsQueryVariables = Types.Exact<{
|
|
509
|
+
input: Types.GetConnectionTagsInput;
|
|
510
|
+
}>;
|
|
511
|
+
export type GetConnectionTagsQuery = {
|
|
512
|
+
__typename?: 'Query';
|
|
513
|
+
getConnectionTags: Array<{
|
|
514
|
+
__typename?: 'IntegrationConnectionTagAssignment';
|
|
515
|
+
id: string;
|
|
516
|
+
tagId: string;
|
|
517
|
+
entityType: string;
|
|
518
|
+
entityId: string;
|
|
519
|
+
source: string;
|
|
520
|
+
assignedBy?: string | null;
|
|
521
|
+
assignedAt?: string | null;
|
|
522
|
+
tag?: {
|
|
523
|
+
__typename?: 'UniversalTag';
|
|
524
|
+
id: string;
|
|
525
|
+
} | null;
|
|
526
|
+
}>;
|
|
527
|
+
};
|
|
528
|
+
export type GetConnectionsQueryVariables = Types.Exact<{
|
|
529
|
+
filter?: Types.InputMaybe<Types.ConnectionFilterInput>;
|
|
530
|
+
pagination?: Types.InputMaybe<Types.IntegrationsPaginationInput>;
|
|
531
|
+
}>;
|
|
532
|
+
export type GetConnectionsQuery = {
|
|
533
|
+
__typename?: 'Query';
|
|
534
|
+
getConnections: {
|
|
535
|
+
__typename?: 'ConnectionList';
|
|
536
|
+
total: number;
|
|
537
|
+
hasMore: boolean;
|
|
538
|
+
items: Array<{
|
|
539
|
+
__typename?: 'IntegrationConnection';
|
|
540
|
+
id: string;
|
|
541
|
+
name: string;
|
|
542
|
+
description?: string | null;
|
|
543
|
+
status: Types.ConnectionStatus;
|
|
544
|
+
lastHealthCheck?: string | null;
|
|
545
|
+
lastUsedAt?: string | null;
|
|
546
|
+
errorMessage?: string | null;
|
|
547
|
+
externalAccountId?: string | null;
|
|
548
|
+
externalAccountEmail?: string | null;
|
|
549
|
+
externalAccountName?: string | null;
|
|
550
|
+
grantedScopes: Array<string>;
|
|
551
|
+
config?: Record<string, unknown> | null;
|
|
552
|
+
metadata?: Record<string, unknown> | null;
|
|
553
|
+
createdBy: string;
|
|
554
|
+
createdAt: string;
|
|
555
|
+
updatedAt: string;
|
|
556
|
+
provider: {
|
|
557
|
+
__typename?: 'IntegrationProvider';
|
|
558
|
+
id: string;
|
|
559
|
+
key: string;
|
|
560
|
+
name: string;
|
|
561
|
+
description?: string | null;
|
|
562
|
+
category: Types.ProviderCategory;
|
|
563
|
+
authType: Types.AuthType;
|
|
564
|
+
icon?: string | null;
|
|
565
|
+
color?: string | null;
|
|
566
|
+
pluginStatus: Types.PluginStatus;
|
|
567
|
+
isEnabled: boolean;
|
|
568
|
+
connectionCount: number;
|
|
569
|
+
};
|
|
570
|
+
tagAssignments: Array<{
|
|
571
|
+
__typename?: 'IntegrationConnectionTagAssignment';
|
|
572
|
+
id: string;
|
|
573
|
+
tagId: string;
|
|
574
|
+
entityType: string;
|
|
575
|
+
entityId: string;
|
|
576
|
+
source: string;
|
|
577
|
+
assignedBy?: string | null;
|
|
578
|
+
assignedAt?: string | null;
|
|
579
|
+
tag?: {
|
|
580
|
+
__typename?: 'UniversalTag';
|
|
581
|
+
id: string;
|
|
582
|
+
} | null;
|
|
583
|
+
}>;
|
|
584
|
+
}>;
|
|
585
|
+
};
|
|
586
|
+
};
|
|
587
|
+
export type GetConnectionsByProviderQueryVariables = Types.Exact<{
|
|
588
|
+
providerId: Types.Scalars['ID']['input'];
|
|
589
|
+
pagination?: Types.InputMaybe<Types.IntegrationsPaginationInput>;
|
|
590
|
+
}>;
|
|
591
|
+
export type GetConnectionsByProviderQuery = {
|
|
592
|
+
__typename?: 'Query';
|
|
593
|
+
getConnectionsByProvider: {
|
|
594
|
+
__typename?: 'ConnectionList';
|
|
595
|
+
total: number;
|
|
596
|
+
items: Array<{
|
|
597
|
+
__typename?: 'IntegrationConnection';
|
|
598
|
+
id: string;
|
|
599
|
+
name: string;
|
|
600
|
+
description?: string | null;
|
|
601
|
+
status: Types.ConnectionStatus;
|
|
602
|
+
lastHealthCheck?: string | null;
|
|
603
|
+
lastUsedAt?: string | null;
|
|
604
|
+
errorMessage?: string | null;
|
|
605
|
+
externalAccountId?: string | null;
|
|
606
|
+
externalAccountEmail?: string | null;
|
|
607
|
+
externalAccountName?: string | null;
|
|
608
|
+
grantedScopes: Array<string>;
|
|
609
|
+
createdBy: string;
|
|
610
|
+
createdAt: string;
|
|
611
|
+
updatedAt: string;
|
|
612
|
+
provider: {
|
|
613
|
+
__typename?: 'IntegrationProvider';
|
|
614
|
+
id: string;
|
|
615
|
+
key: string;
|
|
616
|
+
name: string;
|
|
617
|
+
description?: string | null;
|
|
618
|
+
category: Types.ProviderCategory;
|
|
619
|
+
authType: Types.AuthType;
|
|
620
|
+
icon?: string | null;
|
|
621
|
+
color?: string | null;
|
|
622
|
+
pluginStatus: Types.PluginStatus;
|
|
623
|
+
isEnabled: boolean;
|
|
624
|
+
connectionCount: number;
|
|
625
|
+
};
|
|
626
|
+
}>;
|
|
627
|
+
};
|
|
628
|
+
};
|
|
629
|
+
export type GetIntegrationLogsQueryVariables = Types.Exact<{
|
|
630
|
+
filter?: Types.InputMaybe<Types.LogFilterInput>;
|
|
631
|
+
pagination?: Types.InputMaybe<Types.IntegrationsPaginationInput>;
|
|
632
|
+
}>;
|
|
633
|
+
export type GetIntegrationLogsQuery = {
|
|
634
|
+
__typename?: 'Query';
|
|
635
|
+
getIntegrationLogs: {
|
|
636
|
+
__typename?: 'LogList';
|
|
637
|
+
total: number;
|
|
638
|
+
hasMore: boolean;
|
|
639
|
+
items: Array<{
|
|
640
|
+
__typename?: 'IntegrationLog';
|
|
641
|
+
id: string;
|
|
642
|
+
connectionId?: string | null;
|
|
643
|
+
action: Types.LogAction;
|
|
644
|
+
level: Types.LogLevel;
|
|
645
|
+
message: string;
|
|
646
|
+
requestUrl?: string | null;
|
|
647
|
+
requestMethod?: string | null;
|
|
648
|
+
responseStatus?: number | null;
|
|
649
|
+
metadata?: Record<string, unknown> | null;
|
|
650
|
+
createdAt: string;
|
|
651
|
+
}>;
|
|
652
|
+
};
|
|
653
|
+
};
|
|
654
|
+
export type GetProviderQueryVariables = Types.Exact<{
|
|
655
|
+
id: Types.Scalars['ID']['input'];
|
|
656
|
+
}>;
|
|
657
|
+
export type GetProviderQuery = {
|
|
658
|
+
__typename?: 'Query';
|
|
659
|
+
getProvider?: {
|
|
660
|
+
__typename?: 'IntegrationProvider';
|
|
661
|
+
id: string;
|
|
662
|
+
key: string;
|
|
663
|
+
name: string;
|
|
664
|
+
description?: string | null;
|
|
665
|
+
category: Types.ProviderCategory;
|
|
666
|
+
authType: Types.AuthType;
|
|
667
|
+
icon?: string | null;
|
|
668
|
+
color?: string | null;
|
|
669
|
+
website?: string | null;
|
|
670
|
+
docsUrl?: string | null;
|
|
671
|
+
oauthConfig?: Record<string, unknown> | null;
|
|
672
|
+
defaultScopes: Array<string>;
|
|
673
|
+
availableScopes?: Record<string, unknown> | null;
|
|
674
|
+
baseUrl?: string | null;
|
|
675
|
+
apiVersion?: string | null;
|
|
676
|
+
rateLimitConfig?: Record<string, unknown> | null;
|
|
677
|
+
pluginStatus: Types.PluginStatus;
|
|
678
|
+
pluginVersion?: string | null;
|
|
679
|
+
pluginAuthor?: string | null;
|
|
680
|
+
pluginRepository?: string | null;
|
|
681
|
+
isBuiltIn: boolean;
|
|
682
|
+
isEnabled: boolean;
|
|
683
|
+
displayOrder: number;
|
|
684
|
+
supportedFeatures: Array<string>;
|
|
685
|
+
configSchema?: Record<string, unknown> | null;
|
|
686
|
+
connectionCount: number;
|
|
687
|
+
createdAt: string;
|
|
688
|
+
updatedAt: string;
|
|
689
|
+
} | null;
|
|
690
|
+
};
|
|
691
|
+
export type GetProviderByKeyQueryVariables = Types.Exact<{
|
|
692
|
+
key: Types.Scalars['String']['input'];
|
|
693
|
+
}>;
|
|
694
|
+
export type GetProviderByKeyQuery = {
|
|
695
|
+
__typename?: 'Query';
|
|
696
|
+
getProviderByKey?: {
|
|
697
|
+
__typename?: 'IntegrationProvider';
|
|
698
|
+
id: string;
|
|
699
|
+
key: string;
|
|
700
|
+
name: string;
|
|
701
|
+
description?: string | null;
|
|
702
|
+
category: Types.ProviderCategory;
|
|
703
|
+
authType: Types.AuthType;
|
|
704
|
+
icon?: string | null;
|
|
705
|
+
color?: string | null;
|
|
706
|
+
website?: string | null;
|
|
707
|
+
docsUrl?: string | null;
|
|
708
|
+
oauthConfig?: Record<string, unknown> | null;
|
|
709
|
+
defaultScopes: Array<string>;
|
|
710
|
+
availableScopes?: Record<string, unknown> | null;
|
|
711
|
+
baseUrl?: string | null;
|
|
712
|
+
apiVersion?: string | null;
|
|
713
|
+
rateLimitConfig?: Record<string, unknown> | null;
|
|
714
|
+
pluginStatus: Types.PluginStatus;
|
|
715
|
+
pluginVersion?: string | null;
|
|
716
|
+
pluginAuthor?: string | null;
|
|
717
|
+
pluginRepository?: string | null;
|
|
718
|
+
isBuiltIn: boolean;
|
|
719
|
+
isEnabled: boolean;
|
|
720
|
+
displayOrder: number;
|
|
721
|
+
supportedFeatures: Array<string>;
|
|
722
|
+
configSchema?: Record<string, unknown> | null;
|
|
723
|
+
connectionCount: number;
|
|
724
|
+
createdAt: string;
|
|
725
|
+
updatedAt: string;
|
|
726
|
+
} | null;
|
|
727
|
+
};
|
|
728
|
+
export type GetProviderCatalogQueryVariables = Types.Exact<{
|
|
729
|
+
pagination?: Types.InputMaybe<Types.IntegrationsPaginationInput>;
|
|
730
|
+
}>;
|
|
731
|
+
export type GetProviderCatalogQuery = {
|
|
732
|
+
__typename?: 'Query';
|
|
733
|
+
getProviderCatalog: {
|
|
734
|
+
__typename?: 'ProviderList';
|
|
735
|
+
total: number;
|
|
736
|
+
items: Array<{
|
|
737
|
+
__typename?: 'IntegrationProvider';
|
|
738
|
+
id: string;
|
|
739
|
+
key: string;
|
|
740
|
+
name: string;
|
|
741
|
+
description?: string | null;
|
|
742
|
+
category: Types.ProviderCategory;
|
|
743
|
+
authType: Types.AuthType;
|
|
744
|
+
icon?: string | null;
|
|
745
|
+
color?: string | null;
|
|
746
|
+
website?: string | null;
|
|
747
|
+
docsUrl?: string | null;
|
|
748
|
+
oauthConfig?: Record<string, unknown> | null;
|
|
749
|
+
defaultScopes: Array<string>;
|
|
750
|
+
availableScopes?: Record<string, unknown> | null;
|
|
751
|
+
baseUrl?: string | null;
|
|
752
|
+
apiVersion?: string | null;
|
|
753
|
+
rateLimitConfig?: Record<string, unknown> | null;
|
|
754
|
+
pluginStatus: Types.PluginStatus;
|
|
755
|
+
pluginVersion?: string | null;
|
|
756
|
+
pluginAuthor?: string | null;
|
|
757
|
+
pluginRepository?: string | null;
|
|
758
|
+
isBuiltIn: boolean;
|
|
759
|
+
isEnabled: boolean;
|
|
760
|
+
displayOrder: number;
|
|
761
|
+
supportedFeatures: Array<string>;
|
|
762
|
+
configSchema?: Record<string, unknown> | null;
|
|
763
|
+
connectionCount: number;
|
|
764
|
+
createdAt: string;
|
|
765
|
+
updatedAt: string;
|
|
766
|
+
}>;
|
|
767
|
+
};
|
|
768
|
+
};
|
|
769
|
+
export type GetProvidersQueryVariables = Types.Exact<{
|
|
770
|
+
filter?: Types.InputMaybe<Types.ProviderFilterInput>;
|
|
771
|
+
pagination?: Types.InputMaybe<Types.IntegrationsPaginationInput>;
|
|
772
|
+
}>;
|
|
773
|
+
export type GetProvidersQuery = {
|
|
774
|
+
__typename?: 'Query';
|
|
775
|
+
getProviders: {
|
|
776
|
+
__typename?: 'ProviderList';
|
|
777
|
+
total: number;
|
|
778
|
+
hasMore: boolean;
|
|
779
|
+
items: Array<{
|
|
780
|
+
__typename?: 'IntegrationProvider';
|
|
781
|
+
id: string;
|
|
782
|
+
key: string;
|
|
783
|
+
name: string;
|
|
784
|
+
description?: string | null;
|
|
785
|
+
category: Types.ProviderCategory;
|
|
786
|
+
authType: Types.AuthType;
|
|
787
|
+
icon?: string | null;
|
|
788
|
+
color?: string | null;
|
|
789
|
+
website?: string | null;
|
|
790
|
+
docsUrl?: string | null;
|
|
791
|
+
oauthConfig?: Record<string, unknown> | null;
|
|
792
|
+
defaultScopes: Array<string>;
|
|
793
|
+
availableScopes?: Record<string, unknown> | null;
|
|
794
|
+
baseUrl?: string | null;
|
|
795
|
+
apiVersion?: string | null;
|
|
796
|
+
rateLimitConfig?: Record<string, unknown> | null;
|
|
797
|
+
pluginStatus: Types.PluginStatus;
|
|
798
|
+
pluginVersion?: string | null;
|
|
799
|
+
pluginAuthor?: string | null;
|
|
800
|
+
pluginRepository?: string | null;
|
|
801
|
+
isBuiltIn: boolean;
|
|
802
|
+
isEnabled: boolean;
|
|
803
|
+
displayOrder: number;
|
|
804
|
+
supportedFeatures: Array<string>;
|
|
805
|
+
configSchema?: Record<string, unknown> | null;
|
|
806
|
+
connectionCount: number;
|
|
807
|
+
createdAt: string;
|
|
808
|
+
updatedAt: string;
|
|
809
|
+
}>;
|
|
810
|
+
};
|
|
811
|
+
};
|
|
812
|
+
export type GetVaultSecretsForIntegrationsQueryVariables = Types.Exact<{
|
|
813
|
+
vaultId: Types.Scalars['ID']['input'];
|
|
814
|
+
filter?: Types.InputMaybe<Types.SecretFilterInput>;
|
|
815
|
+
pagination?: Types.InputMaybe<Types.SecurityPaginationInput>;
|
|
816
|
+
}>;
|
|
817
|
+
export type GetVaultSecretsForIntegrationsQuery = {
|
|
818
|
+
__typename?: 'Query';
|
|
819
|
+
getSecrets: {
|
|
820
|
+
__typename?: 'SecretList';
|
|
821
|
+
total: number;
|
|
822
|
+
hasMore: boolean;
|
|
823
|
+
items: Array<{
|
|
824
|
+
__typename?: 'Secret';
|
|
825
|
+
id: string;
|
|
826
|
+
vaultId: string;
|
|
827
|
+
name: string;
|
|
828
|
+
key: string;
|
|
829
|
+
description?: string | null;
|
|
830
|
+
type: Types.SecretType;
|
|
831
|
+
status: Types.SecretStatus;
|
|
832
|
+
}>;
|
|
833
|
+
};
|
|
834
|
+
};
|
|
835
|
+
export type GetVaultsForIntegrationsQueryVariables = Types.Exact<{
|
|
836
|
+
filter?: Types.InputMaybe<Types.VaultFilterInput>;
|
|
837
|
+
pagination?: Types.InputMaybe<Types.SecurityPaginationInput>;
|
|
838
|
+
}>;
|
|
839
|
+
export type GetVaultsForIntegrationsQuery = {
|
|
840
|
+
__typename?: 'Query';
|
|
841
|
+
getVaults: {
|
|
842
|
+
__typename?: 'VaultList';
|
|
843
|
+
total: number;
|
|
844
|
+
hasMore: boolean;
|
|
845
|
+
items: Array<{
|
|
846
|
+
__typename?: 'Vault';
|
|
847
|
+
id: string;
|
|
848
|
+
name: string;
|
|
849
|
+
description?: string | null;
|
|
850
|
+
status: Types.VaultStatus;
|
|
851
|
+
secretCount: number;
|
|
852
|
+
}>;
|
|
853
|
+
};
|
|
854
|
+
};
|
|
855
|
+
export declare const IntegrationProviderSummaryFieldsFragmentDoc: Apollo.DocumentNode;
|
|
856
|
+
export declare const IntegrationConnectionTagAssignmentFieldsFragmentDoc: Apollo.DocumentNode;
|
|
857
|
+
export declare const IntegrationConnectionFieldsFragmentDoc: Apollo.DocumentNode;
|
|
858
|
+
export declare const IntegrationConnectionSummaryFieldsFragmentDoc: Apollo.DocumentNode;
|
|
859
|
+
export declare const IntegrationLogFieldsFragmentDoc: Apollo.DocumentNode;
|
|
860
|
+
export declare const IntegrationProviderFieldsFragmentDoc: Apollo.DocumentNode;
|
|
861
|
+
export declare const AuthenticateWithApiKeyDocument: Apollo.DocumentNode;
|
|
862
|
+
export type AuthenticateWithApiKeyMutationFn = Apollo.MutationFunction<Types.AuthenticateWithApiKeyMutation, Types.AuthenticateWithApiKeyMutationVariables>;
|
|
863
|
+
/**
|
|
864
|
+
* __useAuthenticateWithApiKeyMutation__
|
|
865
|
+
*
|
|
866
|
+
* To run a mutation, you first call `useAuthenticateWithApiKeyMutation` within a React component and pass it any options that fit your needs.
|
|
867
|
+
* When your component renders, `useAuthenticateWithApiKeyMutation` returns a tuple that includes:
|
|
868
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
869
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
870
|
+
*
|
|
871
|
+
* @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;
|
|
872
|
+
*
|
|
873
|
+
* @example
|
|
874
|
+
* const [authenticateWithApiKeyMutation, { data, loading, error }] = useAuthenticateWithApiKeyMutation({
|
|
875
|
+
* variables: {
|
|
876
|
+
* input: // value for 'input'
|
|
877
|
+
* },
|
|
878
|
+
* });
|
|
879
|
+
*/
|
|
880
|
+
export declare function useAuthenticateWithApiKeyMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.AuthenticateWithApiKeyMutation, Types.AuthenticateWithApiKeyMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.AuthenticateWithApiKeyMutation, any, Apollo.ApolloCache>;
|
|
881
|
+
export type AuthenticateWithApiKeyMutationHookResult = ReturnType<typeof useAuthenticateWithApiKeyMutation>;
|
|
882
|
+
export type AuthenticateWithApiKeyMutationResult = Apollo.MutationResult<Types.AuthenticateWithApiKeyMutation>;
|
|
883
|
+
export type AuthenticateWithApiKeyMutationOptions = Apollo.BaseMutationOptions<Types.AuthenticateWithApiKeyMutation, Types.AuthenticateWithApiKeyMutationVariables>;
|
|
884
|
+
export declare const AuthenticateWithBasicAuthDocument: Apollo.DocumentNode;
|
|
885
|
+
export type AuthenticateWithBasicAuthMutationFn = Apollo.MutationFunction<Types.AuthenticateWithBasicAuthMutation, Types.AuthenticateWithBasicAuthMutationVariables>;
|
|
886
|
+
/**
|
|
887
|
+
* __useAuthenticateWithBasicAuthMutation__
|
|
888
|
+
*
|
|
889
|
+
* To run a mutation, you first call `useAuthenticateWithBasicAuthMutation` within a React component and pass it any options that fit your needs.
|
|
890
|
+
* When your component renders, `useAuthenticateWithBasicAuthMutation` returns a tuple that includes:
|
|
891
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
892
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
893
|
+
*
|
|
894
|
+
* @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;
|
|
895
|
+
*
|
|
896
|
+
* @example
|
|
897
|
+
* const [authenticateWithBasicAuthMutation, { data, loading, error }] = useAuthenticateWithBasicAuthMutation({
|
|
898
|
+
* variables: {
|
|
899
|
+
* input: // value for 'input'
|
|
900
|
+
* },
|
|
901
|
+
* });
|
|
902
|
+
*/
|
|
903
|
+
export declare function useAuthenticateWithBasicAuthMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.AuthenticateWithBasicAuthMutation, Types.AuthenticateWithBasicAuthMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.AuthenticateWithBasicAuthMutation, any, Apollo.ApolloCache>;
|
|
904
|
+
export type AuthenticateWithBasicAuthMutationHookResult = ReturnType<typeof useAuthenticateWithBasicAuthMutation>;
|
|
905
|
+
export type AuthenticateWithBasicAuthMutationResult = Apollo.MutationResult<Types.AuthenticateWithBasicAuthMutation>;
|
|
906
|
+
export type AuthenticateWithBasicAuthMutationOptions = Apollo.BaseMutationOptions<Types.AuthenticateWithBasicAuthMutation, Types.AuthenticateWithBasicAuthMutationVariables>;
|
|
907
|
+
export declare const AuthenticateWithBearerTokenDocument: Apollo.DocumentNode;
|
|
908
|
+
export type AuthenticateWithBearerTokenMutationFn = Apollo.MutationFunction<Types.AuthenticateWithBearerTokenMutation, Types.AuthenticateWithBearerTokenMutationVariables>;
|
|
909
|
+
/**
|
|
910
|
+
* __useAuthenticateWithBearerTokenMutation__
|
|
911
|
+
*
|
|
912
|
+
* To run a mutation, you first call `useAuthenticateWithBearerTokenMutation` within a React component and pass it any options that fit your needs.
|
|
913
|
+
* When your component renders, `useAuthenticateWithBearerTokenMutation` returns a tuple that includes:
|
|
914
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
915
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
916
|
+
*
|
|
917
|
+
* @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;
|
|
918
|
+
*
|
|
919
|
+
* @example
|
|
920
|
+
* const [authenticateWithBearerTokenMutation, { data, loading, error }] = useAuthenticateWithBearerTokenMutation({
|
|
921
|
+
* variables: {
|
|
922
|
+
* input: // value for 'input'
|
|
923
|
+
* },
|
|
924
|
+
* });
|
|
925
|
+
*/
|
|
926
|
+
export declare function useAuthenticateWithBearerTokenMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.AuthenticateWithBearerTokenMutation, Types.AuthenticateWithBearerTokenMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.AuthenticateWithBearerTokenMutation, any, Apollo.ApolloCache>;
|
|
927
|
+
export type AuthenticateWithBearerTokenMutationHookResult = ReturnType<typeof useAuthenticateWithBearerTokenMutation>;
|
|
928
|
+
export type AuthenticateWithBearerTokenMutationResult = Apollo.MutationResult<Types.AuthenticateWithBearerTokenMutation>;
|
|
929
|
+
export type AuthenticateWithBearerTokenMutationOptions = Apollo.BaseMutationOptions<Types.AuthenticateWithBearerTokenMutation, Types.AuthenticateWithBearerTokenMutationVariables>;
|
|
930
|
+
export declare const CompleteOAuthDocument: Apollo.DocumentNode;
|
|
931
|
+
export type CompleteOAuthMutationFn = Apollo.MutationFunction<Types.CompleteOAuthMutation, Types.CompleteOAuthMutationVariables>;
|
|
932
|
+
/**
|
|
933
|
+
* __useCompleteOAuthMutation__
|
|
934
|
+
*
|
|
935
|
+
* To run a mutation, you first call `useCompleteOAuthMutation` within a React component and pass it any options that fit your needs.
|
|
936
|
+
* When your component renders, `useCompleteOAuthMutation` returns a tuple that includes:
|
|
937
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
938
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
939
|
+
*
|
|
940
|
+
* @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;
|
|
941
|
+
*
|
|
942
|
+
* @example
|
|
943
|
+
* const [completeOAuthMutation, { data, loading, error }] = useCompleteOAuthMutation({
|
|
944
|
+
* variables: {
|
|
945
|
+
* input: // value for 'input'
|
|
946
|
+
* },
|
|
947
|
+
* });
|
|
948
|
+
*/
|
|
949
|
+
export declare function useCompleteOAuthMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CompleteOAuthMutation, Types.CompleteOAuthMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CompleteOAuthMutation, any, Apollo.ApolloCache>;
|
|
950
|
+
export type CompleteOAuthMutationHookResult = ReturnType<typeof useCompleteOAuthMutation>;
|
|
951
|
+
export type CompleteOAuthMutationResult = Apollo.MutationResult<Types.CompleteOAuthMutation>;
|
|
952
|
+
export type CompleteOAuthMutationOptions = Apollo.BaseMutationOptions<Types.CompleteOAuthMutation, Types.CompleteOAuthMutationVariables>;
|
|
953
|
+
export declare const CreateConnectionDocument: Apollo.DocumentNode;
|
|
954
|
+
export type CreateConnectionMutationFn = Apollo.MutationFunction<Types.CreateConnectionMutation, Types.CreateConnectionMutationVariables>;
|
|
955
|
+
/**
|
|
956
|
+
* __useCreateConnectionMutation__
|
|
957
|
+
*
|
|
958
|
+
* To run a mutation, you first call `useCreateConnectionMutation` within a React component and pass it any options that fit your needs.
|
|
959
|
+
* When your component renders, `useCreateConnectionMutation` returns a tuple that includes:
|
|
960
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
961
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
962
|
+
*
|
|
963
|
+
* @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;
|
|
964
|
+
*
|
|
965
|
+
* @example
|
|
966
|
+
* const [createConnectionMutation, { data, loading, error }] = useCreateConnectionMutation({
|
|
967
|
+
* variables: {
|
|
968
|
+
* input: // value for 'input'
|
|
969
|
+
* },
|
|
970
|
+
* });
|
|
971
|
+
*/
|
|
972
|
+
export declare function useCreateConnectionMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateConnectionMutation, Types.CreateConnectionMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateConnectionMutation, any, Apollo.ApolloCache>;
|
|
973
|
+
export type CreateConnectionMutationHookResult = ReturnType<typeof useCreateConnectionMutation>;
|
|
974
|
+
export type CreateConnectionMutationResult = Apollo.MutationResult<Types.CreateConnectionMutation>;
|
|
975
|
+
export type CreateConnectionMutationOptions = Apollo.BaseMutationOptions<Types.CreateConnectionMutation, Types.CreateConnectionMutationVariables>;
|
|
976
|
+
export declare const DeleteConnectionDocument: Apollo.DocumentNode;
|
|
977
|
+
export type DeleteConnectionMutationFn = Apollo.MutationFunction<Types.DeleteConnectionMutation, Types.DeleteConnectionMutationVariables>;
|
|
978
|
+
/**
|
|
979
|
+
* __useDeleteConnectionMutation__
|
|
980
|
+
*
|
|
981
|
+
* To run a mutation, you first call `useDeleteConnectionMutation` within a React component and pass it any options that fit your needs.
|
|
982
|
+
* When your component renders, `useDeleteConnectionMutation` returns a tuple that includes:
|
|
983
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
984
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
985
|
+
*
|
|
986
|
+
* @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;
|
|
987
|
+
*
|
|
988
|
+
* @example
|
|
989
|
+
* const [deleteConnectionMutation, { data, loading, error }] = useDeleteConnectionMutation({
|
|
990
|
+
* variables: {
|
|
991
|
+
* id: // value for 'id'
|
|
992
|
+
* deleteVaultSecret: // value for 'deleteVaultSecret'
|
|
993
|
+
* },
|
|
994
|
+
* });
|
|
995
|
+
*/
|
|
996
|
+
export declare function useDeleteConnectionMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteConnectionMutation, Types.DeleteConnectionMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteConnectionMutation, any, Apollo.ApolloCache>;
|
|
997
|
+
export type DeleteConnectionMutationHookResult = ReturnType<typeof useDeleteConnectionMutation>;
|
|
998
|
+
export type DeleteConnectionMutationResult = Apollo.MutationResult<Types.DeleteConnectionMutation>;
|
|
999
|
+
export type DeleteConnectionMutationOptions = Apollo.BaseMutationOptions<Types.DeleteConnectionMutation, Types.DeleteConnectionMutationVariables>;
|
|
1000
|
+
export declare const DisableProviderDocument: Apollo.DocumentNode;
|
|
1001
|
+
export type DisableProviderMutationFn = Apollo.MutationFunction<Types.DisableProviderMutation, Types.DisableProviderMutationVariables>;
|
|
1002
|
+
/**
|
|
1003
|
+
* __useDisableProviderMutation__
|
|
1004
|
+
*
|
|
1005
|
+
* To run a mutation, you first call `useDisableProviderMutation` within a React component and pass it any options that fit your needs.
|
|
1006
|
+
* When your component renders, `useDisableProviderMutation` returns a tuple that includes:
|
|
1007
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
1008
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
1009
|
+
*
|
|
1010
|
+
* @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;
|
|
1011
|
+
*
|
|
1012
|
+
* @example
|
|
1013
|
+
* const [disableProviderMutation, { data, loading, error }] = useDisableProviderMutation({
|
|
1014
|
+
* variables: {
|
|
1015
|
+
* id: // value for 'id'
|
|
1016
|
+
* },
|
|
1017
|
+
* });
|
|
1018
|
+
*/
|
|
1019
|
+
export declare function useDisableProviderMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DisableProviderMutation, Types.DisableProviderMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DisableProviderMutation, any, Apollo.ApolloCache>;
|
|
1020
|
+
export type DisableProviderMutationHookResult = ReturnType<typeof useDisableProviderMutation>;
|
|
1021
|
+
export type DisableProviderMutationResult = Apollo.MutationResult<Types.DisableProviderMutation>;
|
|
1022
|
+
export type DisableProviderMutationOptions = Apollo.BaseMutationOptions<Types.DisableProviderMutation, Types.DisableProviderMutationVariables>;
|
|
1023
|
+
export declare const EnableProviderDocument: Apollo.DocumentNode;
|
|
1024
|
+
export type EnableProviderMutationFn = Apollo.MutationFunction<Types.EnableProviderMutation, Types.EnableProviderMutationVariables>;
|
|
1025
|
+
/**
|
|
1026
|
+
* __useEnableProviderMutation__
|
|
1027
|
+
*
|
|
1028
|
+
* To run a mutation, you first call `useEnableProviderMutation` within a React component and pass it any options that fit your needs.
|
|
1029
|
+
* When your component renders, `useEnableProviderMutation` returns a tuple that includes:
|
|
1030
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
1031
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
1032
|
+
*
|
|
1033
|
+
* @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;
|
|
1034
|
+
*
|
|
1035
|
+
* @example
|
|
1036
|
+
* const [enableProviderMutation, { data, loading, error }] = useEnableProviderMutation({
|
|
1037
|
+
* variables: {
|
|
1038
|
+
* id: // value for 'id'
|
|
1039
|
+
* },
|
|
1040
|
+
* });
|
|
1041
|
+
*/
|
|
1042
|
+
export declare function useEnableProviderMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.EnableProviderMutation, Types.EnableProviderMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.EnableProviderMutation, any, Apollo.ApolloCache>;
|
|
1043
|
+
export type EnableProviderMutationHookResult = ReturnType<typeof useEnableProviderMutation>;
|
|
1044
|
+
export type EnableProviderMutationResult = Apollo.MutationResult<Types.EnableProviderMutation>;
|
|
1045
|
+
export type EnableProviderMutationOptions = Apollo.BaseMutationOptions<Types.EnableProviderMutation, Types.EnableProviderMutationVariables>;
|
|
1046
|
+
export declare const InitiateOAuthDocument: Apollo.DocumentNode;
|
|
1047
|
+
export type InitiateOAuthMutationFn = Apollo.MutationFunction<Types.InitiateOAuthMutation, Types.InitiateOAuthMutationVariables>;
|
|
1048
|
+
/**
|
|
1049
|
+
* __useInitiateOAuthMutation__
|
|
1050
|
+
*
|
|
1051
|
+
* To run a mutation, you first call `useInitiateOAuthMutation` within a React component and pass it any options that fit your needs.
|
|
1052
|
+
* When your component renders, `useInitiateOAuthMutation` returns a tuple that includes:
|
|
1053
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
1054
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
1055
|
+
*
|
|
1056
|
+
* @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;
|
|
1057
|
+
*
|
|
1058
|
+
* @example
|
|
1059
|
+
* const [initiateOAuthMutation, { data, loading, error }] = useInitiateOAuthMutation({
|
|
1060
|
+
* variables: {
|
|
1061
|
+
* input: // value for 'input'
|
|
1062
|
+
* },
|
|
1063
|
+
* });
|
|
1064
|
+
*/
|
|
1065
|
+
export declare function useInitiateOAuthMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.InitiateOAuthMutation, Types.InitiateOAuthMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.InitiateOAuthMutation, any, Apollo.ApolloCache>;
|
|
1066
|
+
export type InitiateOAuthMutationHookResult = ReturnType<typeof useInitiateOAuthMutation>;
|
|
1067
|
+
export type InitiateOAuthMutationResult = Apollo.MutationResult<Types.InitiateOAuthMutation>;
|
|
1068
|
+
export type InitiateOAuthMutationOptions = Apollo.BaseMutationOptions<Types.InitiateOAuthMutation, Types.InitiateOAuthMutationVariables>;
|
|
1069
|
+
export declare const InstallProviderPluginDocument: Apollo.DocumentNode;
|
|
1070
|
+
export type InstallProviderPluginMutationFn = Apollo.MutationFunction<Types.InstallProviderPluginMutation, Types.InstallProviderPluginMutationVariables>;
|
|
1071
|
+
/**
|
|
1072
|
+
* __useInstallProviderPluginMutation__
|
|
1073
|
+
*
|
|
1074
|
+
* To run a mutation, you first call `useInstallProviderPluginMutation` within a React component and pass it any options that fit your needs.
|
|
1075
|
+
* When your component renders, `useInstallProviderPluginMutation` returns a tuple that includes:
|
|
1076
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
1077
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
1078
|
+
*
|
|
1079
|
+
* @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;
|
|
1080
|
+
*
|
|
1081
|
+
* @example
|
|
1082
|
+
* const [installProviderPluginMutation, { data, loading, error }] = useInstallProviderPluginMutation({
|
|
1083
|
+
* variables: {
|
|
1084
|
+
* input: // value for 'input'
|
|
1085
|
+
* },
|
|
1086
|
+
* });
|
|
1087
|
+
*/
|
|
1088
|
+
export declare function useInstallProviderPluginMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.InstallProviderPluginMutation, Types.InstallProviderPluginMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.InstallProviderPluginMutation, any, Apollo.ApolloCache>;
|
|
1089
|
+
export type InstallProviderPluginMutationHookResult = ReturnType<typeof useInstallProviderPluginMutation>;
|
|
1090
|
+
export type InstallProviderPluginMutationResult = Apollo.MutationResult<Types.InstallProviderPluginMutation>;
|
|
1091
|
+
export type InstallProviderPluginMutationOptions = Apollo.BaseMutationOptions<Types.InstallProviderPluginMutation, Types.InstallProviderPluginMutationVariables>;
|
|
1092
|
+
export declare const RefreshConnectionTokenDocument: Apollo.DocumentNode;
|
|
1093
|
+
export type RefreshConnectionTokenMutationFn = Apollo.MutationFunction<Types.RefreshConnectionTokenMutation, Types.RefreshConnectionTokenMutationVariables>;
|
|
1094
|
+
/**
|
|
1095
|
+
* __useRefreshConnectionTokenMutation__
|
|
1096
|
+
*
|
|
1097
|
+
* To run a mutation, you first call `useRefreshConnectionTokenMutation` within a React component and pass it any options that fit your needs.
|
|
1098
|
+
* When your component renders, `useRefreshConnectionTokenMutation` returns a tuple that includes:
|
|
1099
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
1100
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
1101
|
+
*
|
|
1102
|
+
* @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;
|
|
1103
|
+
*
|
|
1104
|
+
* @example
|
|
1105
|
+
* const [refreshConnectionTokenMutation, { data, loading, error }] = useRefreshConnectionTokenMutation({
|
|
1106
|
+
* variables: {
|
|
1107
|
+
* connectionId: // value for 'connectionId'
|
|
1108
|
+
* },
|
|
1109
|
+
* });
|
|
1110
|
+
*/
|
|
1111
|
+
export declare function useRefreshConnectionTokenMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RefreshConnectionTokenMutation, Types.RefreshConnectionTokenMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RefreshConnectionTokenMutation, any, Apollo.ApolloCache>;
|
|
1112
|
+
export type RefreshConnectionTokenMutationHookResult = ReturnType<typeof useRefreshConnectionTokenMutation>;
|
|
1113
|
+
export type RefreshConnectionTokenMutationResult = Apollo.MutationResult<Types.RefreshConnectionTokenMutation>;
|
|
1114
|
+
export type RefreshConnectionTokenMutationOptions = Apollo.BaseMutationOptions<Types.RefreshConnectionTokenMutation, Types.RefreshConnectionTokenMutationVariables>;
|
|
1115
|
+
export declare const RevokeConnectionDocument: Apollo.DocumentNode;
|
|
1116
|
+
export type RevokeConnectionMutationFn = Apollo.MutationFunction<Types.RevokeConnectionMutation, Types.RevokeConnectionMutationVariables>;
|
|
1117
|
+
/**
|
|
1118
|
+
* __useRevokeConnectionMutation__
|
|
1119
|
+
*
|
|
1120
|
+
* To run a mutation, you first call `useRevokeConnectionMutation` within a React component and pass it any options that fit your needs.
|
|
1121
|
+
* When your component renders, `useRevokeConnectionMutation` returns a tuple that includes:
|
|
1122
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
1123
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
1124
|
+
*
|
|
1125
|
+
* @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;
|
|
1126
|
+
*
|
|
1127
|
+
* @example
|
|
1128
|
+
* const [revokeConnectionMutation, { data, loading, error }] = useRevokeConnectionMutation({
|
|
1129
|
+
* variables: {
|
|
1130
|
+
* connectionId: // value for 'connectionId'
|
|
1131
|
+
* },
|
|
1132
|
+
* });
|
|
1133
|
+
*/
|
|
1134
|
+
export declare function useRevokeConnectionMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RevokeConnectionMutation, Types.RevokeConnectionMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RevokeConnectionMutation, any, Apollo.ApolloCache>;
|
|
1135
|
+
export type RevokeConnectionMutationHookResult = ReturnType<typeof useRevokeConnectionMutation>;
|
|
1136
|
+
export type RevokeConnectionMutationResult = Apollo.MutationResult<Types.RevokeConnectionMutation>;
|
|
1137
|
+
export type RevokeConnectionMutationOptions = Apollo.BaseMutationOptions<Types.RevokeConnectionMutation, Types.RevokeConnectionMutationVariables>;
|
|
1138
|
+
export declare const TagConnectionDocument: Apollo.DocumentNode;
|
|
1139
|
+
export type TagConnectionMutationFn = Apollo.MutationFunction<Types.TagConnectionMutation, Types.TagConnectionMutationVariables>;
|
|
1140
|
+
/**
|
|
1141
|
+
* __useTagConnectionMutation__
|
|
1142
|
+
*
|
|
1143
|
+
* To run a mutation, you first call `useTagConnectionMutation` within a React component and pass it any options that fit your needs.
|
|
1144
|
+
* When your component renders, `useTagConnectionMutation` returns a tuple that includes:
|
|
1145
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
1146
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
1147
|
+
*
|
|
1148
|
+
* @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;
|
|
1149
|
+
*
|
|
1150
|
+
* @example
|
|
1151
|
+
* const [tagConnectionMutation, { data, loading, error }] = useTagConnectionMutation({
|
|
1152
|
+
* variables: {
|
|
1153
|
+
* input: // value for 'input'
|
|
1154
|
+
* },
|
|
1155
|
+
* });
|
|
1156
|
+
*/
|
|
1157
|
+
export declare function useTagConnectionMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.TagConnectionMutation, Types.TagConnectionMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.TagConnectionMutation, any, Apollo.ApolloCache>;
|
|
1158
|
+
export type TagConnectionMutationHookResult = ReturnType<typeof useTagConnectionMutation>;
|
|
1159
|
+
export type TagConnectionMutationResult = Apollo.MutationResult<Types.TagConnectionMutation>;
|
|
1160
|
+
export type TagConnectionMutationOptions = Apollo.BaseMutationOptions<Types.TagConnectionMutation, Types.TagConnectionMutationVariables>;
|
|
1161
|
+
export declare const UntagConnectionDocument: Apollo.DocumentNode;
|
|
1162
|
+
export type UntagConnectionMutationFn = Apollo.MutationFunction<Types.UntagConnectionMutation, Types.UntagConnectionMutationVariables>;
|
|
1163
|
+
/**
|
|
1164
|
+
* __useUntagConnectionMutation__
|
|
1165
|
+
*
|
|
1166
|
+
* To run a mutation, you first call `useUntagConnectionMutation` within a React component and pass it any options that fit your needs.
|
|
1167
|
+
* When your component renders, `useUntagConnectionMutation` returns a tuple that includes:
|
|
1168
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
1169
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
1170
|
+
*
|
|
1171
|
+
* @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;
|
|
1172
|
+
*
|
|
1173
|
+
* @example
|
|
1174
|
+
* const [untagConnectionMutation, { data, loading, error }] = useUntagConnectionMutation({
|
|
1175
|
+
* variables: {
|
|
1176
|
+
* input: // value for 'input'
|
|
1177
|
+
* },
|
|
1178
|
+
* });
|
|
1179
|
+
*/
|
|
1180
|
+
export declare function useUntagConnectionMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UntagConnectionMutation, Types.UntagConnectionMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UntagConnectionMutation, any, Apollo.ApolloCache>;
|
|
1181
|
+
export type UntagConnectionMutationHookResult = ReturnType<typeof useUntagConnectionMutation>;
|
|
1182
|
+
export type UntagConnectionMutationResult = Apollo.MutationResult<Types.UntagConnectionMutation>;
|
|
1183
|
+
export type UntagConnectionMutationOptions = Apollo.BaseMutationOptions<Types.UntagConnectionMutation, Types.UntagConnectionMutationVariables>;
|
|
1184
|
+
export declare const ReplaceConnectionTagsDocument: Apollo.DocumentNode;
|
|
1185
|
+
export type ReplaceConnectionTagsMutationFn = Apollo.MutationFunction<Types.ReplaceConnectionTagsMutation, Types.ReplaceConnectionTagsMutationVariables>;
|
|
1186
|
+
/**
|
|
1187
|
+
* __useReplaceConnectionTagsMutation__
|
|
1188
|
+
*
|
|
1189
|
+
* To run a mutation, you first call `useReplaceConnectionTagsMutation` within a React component and pass it any options that fit your needs.
|
|
1190
|
+
* When your component renders, `useReplaceConnectionTagsMutation` returns a tuple that includes:
|
|
1191
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
1192
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
1193
|
+
*
|
|
1194
|
+
* @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;
|
|
1195
|
+
*
|
|
1196
|
+
* @example
|
|
1197
|
+
* const [replaceConnectionTagsMutation, { data, loading, error }] = useReplaceConnectionTagsMutation({
|
|
1198
|
+
* variables: {
|
|
1199
|
+
* input: // value for 'input'
|
|
1200
|
+
* },
|
|
1201
|
+
* });
|
|
1202
|
+
*/
|
|
1203
|
+
export declare function useReplaceConnectionTagsMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ReplaceConnectionTagsMutation, Types.ReplaceConnectionTagsMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ReplaceConnectionTagsMutation, any, Apollo.ApolloCache>;
|
|
1204
|
+
export type ReplaceConnectionTagsMutationHookResult = ReturnType<typeof useReplaceConnectionTagsMutation>;
|
|
1205
|
+
export type ReplaceConnectionTagsMutationResult = Apollo.MutationResult<Types.ReplaceConnectionTagsMutation>;
|
|
1206
|
+
export type ReplaceConnectionTagsMutationOptions = Apollo.BaseMutationOptions<Types.ReplaceConnectionTagsMutation, Types.ReplaceConnectionTagsMutationVariables>;
|
|
1207
|
+
export declare const TestConnectionDocument: Apollo.DocumentNode;
|
|
1208
|
+
export type TestConnectionMutationFn = Apollo.MutationFunction<Types.TestConnectionMutation, Types.TestConnectionMutationVariables>;
|
|
1209
|
+
/**
|
|
1210
|
+
* __useTestConnectionMutation__
|
|
1211
|
+
*
|
|
1212
|
+
* To run a mutation, you first call `useTestConnectionMutation` within a React component and pass it any options that fit your needs.
|
|
1213
|
+
* When your component renders, `useTestConnectionMutation` returns a tuple that includes:
|
|
1214
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
1215
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
1216
|
+
*
|
|
1217
|
+
* @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;
|
|
1218
|
+
*
|
|
1219
|
+
* @example
|
|
1220
|
+
* const [testConnectionMutation, { data, loading, error }] = useTestConnectionMutation({
|
|
1221
|
+
* variables: {
|
|
1222
|
+
* connectionId: // value for 'connectionId'
|
|
1223
|
+
* },
|
|
1224
|
+
* });
|
|
1225
|
+
*/
|
|
1226
|
+
export declare function useTestConnectionMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.TestConnectionMutation, Types.TestConnectionMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.TestConnectionMutation, any, Apollo.ApolloCache>;
|
|
1227
|
+
export type TestConnectionMutationHookResult = ReturnType<typeof useTestConnectionMutation>;
|
|
1228
|
+
export type TestConnectionMutationResult = Apollo.MutationResult<Types.TestConnectionMutation>;
|
|
1229
|
+
export type TestConnectionMutationOptions = Apollo.BaseMutationOptions<Types.TestConnectionMutation, Types.TestConnectionMutationVariables>;
|
|
1230
|
+
export declare const UninstallProviderPluginDocument: Apollo.DocumentNode;
|
|
1231
|
+
export type UninstallProviderPluginMutationFn = Apollo.MutationFunction<Types.UninstallProviderPluginMutation, Types.UninstallProviderPluginMutationVariables>;
|
|
1232
|
+
/**
|
|
1233
|
+
* __useUninstallProviderPluginMutation__
|
|
1234
|
+
*
|
|
1235
|
+
* To run a mutation, you first call `useUninstallProviderPluginMutation` within a React component and pass it any options that fit your needs.
|
|
1236
|
+
* When your component renders, `useUninstallProviderPluginMutation` returns a tuple that includes:
|
|
1237
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
1238
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
1239
|
+
*
|
|
1240
|
+
* @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;
|
|
1241
|
+
*
|
|
1242
|
+
* @example
|
|
1243
|
+
* const [uninstallProviderPluginMutation, { data, loading, error }] = useUninstallProviderPluginMutation({
|
|
1244
|
+
* variables: {
|
|
1245
|
+
* id: // value for 'id'
|
|
1246
|
+
* },
|
|
1247
|
+
* });
|
|
1248
|
+
*/
|
|
1249
|
+
export declare function useUninstallProviderPluginMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UninstallProviderPluginMutation, Types.UninstallProviderPluginMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UninstallProviderPluginMutation, any, Apollo.ApolloCache>;
|
|
1250
|
+
export type UninstallProviderPluginMutationHookResult = ReturnType<typeof useUninstallProviderPluginMutation>;
|
|
1251
|
+
export type UninstallProviderPluginMutationResult = Apollo.MutationResult<Types.UninstallProviderPluginMutation>;
|
|
1252
|
+
export type UninstallProviderPluginMutationOptions = Apollo.BaseMutationOptions<Types.UninstallProviderPluginMutation, Types.UninstallProviderPluginMutationVariables>;
|
|
1253
|
+
export declare const UpdateConnectionDocument: Apollo.DocumentNode;
|
|
1254
|
+
export type UpdateConnectionMutationFn = Apollo.MutationFunction<Types.UpdateConnectionMutation, Types.UpdateConnectionMutationVariables>;
|
|
1255
|
+
/**
|
|
1256
|
+
* __useUpdateConnectionMutation__
|
|
1257
|
+
*
|
|
1258
|
+
* To run a mutation, you first call `useUpdateConnectionMutation` within a React component and pass it any options that fit your needs.
|
|
1259
|
+
* When your component renders, `useUpdateConnectionMutation` returns a tuple that includes:
|
|
1260
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
1261
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
1262
|
+
*
|
|
1263
|
+
* @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;
|
|
1264
|
+
*
|
|
1265
|
+
* @example
|
|
1266
|
+
* const [updateConnectionMutation, { data, loading, error }] = useUpdateConnectionMutation({
|
|
1267
|
+
* variables: {
|
|
1268
|
+
* id: // value for 'id'
|
|
1269
|
+
* input: // value for 'input'
|
|
1270
|
+
* },
|
|
1271
|
+
* });
|
|
1272
|
+
*/
|
|
1273
|
+
export declare function useUpdateConnectionMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateConnectionMutation, Types.UpdateConnectionMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateConnectionMutation, any, Apollo.ApolloCache>;
|
|
1274
|
+
export type UpdateConnectionMutationHookResult = ReturnType<typeof useUpdateConnectionMutation>;
|
|
1275
|
+
export type UpdateConnectionMutationResult = Apollo.MutationResult<Types.UpdateConnectionMutation>;
|
|
1276
|
+
export type UpdateConnectionMutationOptions = Apollo.BaseMutationOptions<Types.UpdateConnectionMutation, Types.UpdateConnectionMutationVariables>;
|
|
1277
|
+
export declare const UpdateProviderPluginDocument: Apollo.DocumentNode;
|
|
1278
|
+
export type UpdateProviderPluginMutationFn = Apollo.MutationFunction<Types.UpdateProviderPluginMutation, Types.UpdateProviderPluginMutationVariables>;
|
|
1279
|
+
/**
|
|
1280
|
+
* __useUpdateProviderPluginMutation__
|
|
1281
|
+
*
|
|
1282
|
+
* To run a mutation, you first call `useUpdateProviderPluginMutation` within a React component and pass it any options that fit your needs.
|
|
1283
|
+
* When your component renders, `useUpdateProviderPluginMutation` returns a tuple that includes:
|
|
1284
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
1285
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
1286
|
+
*
|
|
1287
|
+
* @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;
|
|
1288
|
+
*
|
|
1289
|
+
* @example
|
|
1290
|
+
* const [updateProviderPluginMutation, { data, loading, error }] = useUpdateProviderPluginMutation({
|
|
1291
|
+
* variables: {
|
|
1292
|
+
* id: // value for 'id'
|
|
1293
|
+
* input: // value for 'input'
|
|
1294
|
+
* },
|
|
1295
|
+
* });
|
|
1296
|
+
*/
|
|
1297
|
+
export declare function useUpdateProviderPluginMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateProviderPluginMutation, Types.UpdateProviderPluginMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateProviderPluginMutation, any, Apollo.ApolloCache>;
|
|
1298
|
+
export type UpdateProviderPluginMutationHookResult = ReturnType<typeof useUpdateProviderPluginMutation>;
|
|
1299
|
+
export type UpdateProviderPluginMutationResult = Apollo.MutationResult<Types.UpdateProviderPluginMutation>;
|
|
1300
|
+
export type UpdateProviderPluginMutationOptions = Apollo.BaseMutationOptions<Types.UpdateProviderPluginMutation, Types.UpdateProviderPluginMutationVariables>;
|
|
1301
|
+
export declare const GetConnectionDocument: Apollo.DocumentNode;
|
|
1302
|
+
/**
|
|
1303
|
+
* __useGetConnectionQuery__
|
|
1304
|
+
*
|
|
1305
|
+
* To run a query within a React component, call `useGetConnectionQuery` and pass it any options that fit your needs.
|
|
1306
|
+
* When your component renders, `useGetConnectionQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
1307
|
+
* you can use to render your UI.
|
|
1308
|
+
*
|
|
1309
|
+
* @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;
|
|
1310
|
+
*
|
|
1311
|
+
* @example
|
|
1312
|
+
* const { data, loading, error } = useGetConnectionQuery({
|
|
1313
|
+
* variables: {
|
|
1314
|
+
* id: // value for 'id'
|
|
1315
|
+
* },
|
|
1316
|
+
* });
|
|
1317
|
+
*/
|
|
1318
|
+
export declare function useGetConnectionQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetConnectionQuery, Types.GetConnectionQueryVariables> & ({
|
|
1319
|
+
variables: Types.GetConnectionQueryVariables;
|
|
1320
|
+
skip?: boolean;
|
|
1321
|
+
} | {
|
|
1322
|
+
skip: boolean;
|
|
1323
|
+
})): ApolloReactHooks.useQuery.Result<Types.GetConnectionQuery, Types.GetConnectionQueryVariables, "complete" | "empty" | "streaming", Types.GetConnectionQueryVariables>;
|
|
1324
|
+
export declare function useGetConnectionLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetConnectionQuery, Types.GetConnectionQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetConnectionQuery, Types.GetConnectionQueryVariables, "complete" | "empty" | "streaming">;
|
|
1325
|
+
export declare function useGetConnectionSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetConnectionQuery, Types.GetConnectionQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetConnectionQuery, Types.GetConnectionQueryVariables>;
|
|
1326
|
+
export declare function useGetConnectionSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetConnectionQuery, Types.GetConnectionQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetConnectionQuery | undefined, Types.GetConnectionQueryVariables>;
|
|
1327
|
+
export type GetConnectionQueryHookResult = ReturnType<typeof useGetConnectionQuery>;
|
|
1328
|
+
export type GetConnectionLazyQueryHookResult = ReturnType<typeof useGetConnectionLazyQuery>;
|
|
1329
|
+
export type GetConnectionSuspenseQueryHookResult = ReturnType<typeof useGetConnectionSuspenseQuery>;
|
|
1330
|
+
export type GetConnectionQueryResult = Apollo.QueryResult<Types.GetConnectionQuery, Types.GetConnectionQueryVariables>;
|
|
1331
|
+
export declare const GetConnectionLogsDocument: Apollo.DocumentNode;
|
|
1332
|
+
/**
|
|
1333
|
+
* __useGetConnectionLogsQuery__
|
|
1334
|
+
*
|
|
1335
|
+
* To run a query within a React component, call `useGetConnectionLogsQuery` and pass it any options that fit your needs.
|
|
1336
|
+
* When your component renders, `useGetConnectionLogsQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
1337
|
+
* you can use to render your UI.
|
|
1338
|
+
*
|
|
1339
|
+
* @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;
|
|
1340
|
+
*
|
|
1341
|
+
* @example
|
|
1342
|
+
* const { data, loading, error } = useGetConnectionLogsQuery({
|
|
1343
|
+
* variables: {
|
|
1344
|
+
* connectionId: // value for 'connectionId'
|
|
1345
|
+
* filter: // value for 'filter'
|
|
1346
|
+
* pagination: // value for 'pagination'
|
|
1347
|
+
* },
|
|
1348
|
+
* });
|
|
1349
|
+
*/
|
|
1350
|
+
export declare function useGetConnectionLogsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetConnectionLogsQuery, Types.GetConnectionLogsQueryVariables> & ({
|
|
1351
|
+
variables: Types.GetConnectionLogsQueryVariables;
|
|
1352
|
+
skip?: boolean;
|
|
1353
|
+
} | {
|
|
1354
|
+
skip: boolean;
|
|
1355
|
+
})): ApolloReactHooks.useQuery.Result<Types.GetConnectionLogsQuery, Types.GetConnectionLogsQueryVariables, "complete" | "empty" | "streaming", Types.GetConnectionLogsQueryVariables>;
|
|
1356
|
+
export declare function useGetConnectionLogsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetConnectionLogsQuery, Types.GetConnectionLogsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetConnectionLogsQuery, Types.GetConnectionLogsQueryVariables, "complete" | "empty" | "streaming">;
|
|
1357
|
+
export declare function useGetConnectionLogsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetConnectionLogsQuery, Types.GetConnectionLogsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetConnectionLogsQuery, Types.GetConnectionLogsQueryVariables>;
|
|
1358
|
+
export declare function useGetConnectionLogsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetConnectionLogsQuery, Types.GetConnectionLogsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetConnectionLogsQuery | undefined, Types.GetConnectionLogsQueryVariables>;
|
|
1359
|
+
export type GetConnectionLogsQueryHookResult = ReturnType<typeof useGetConnectionLogsQuery>;
|
|
1360
|
+
export type GetConnectionLogsLazyQueryHookResult = ReturnType<typeof useGetConnectionLogsLazyQuery>;
|
|
1361
|
+
export type GetConnectionLogsSuspenseQueryHookResult = ReturnType<typeof useGetConnectionLogsSuspenseQuery>;
|
|
1362
|
+
export type GetConnectionLogsQueryResult = Apollo.QueryResult<Types.GetConnectionLogsQuery, Types.GetConnectionLogsQueryVariables>;
|
|
1363
|
+
export declare const GetConnectionTagsDocument: Apollo.DocumentNode;
|
|
1364
|
+
/**
|
|
1365
|
+
* __useGetConnectionTagsQuery__
|
|
1366
|
+
*
|
|
1367
|
+
* To run a query within a React component, call `useGetConnectionTagsQuery` and pass it any options that fit your needs.
|
|
1368
|
+
* When your component renders, `useGetConnectionTagsQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
1369
|
+
* you can use to render your UI.
|
|
1370
|
+
*
|
|
1371
|
+
* @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;
|
|
1372
|
+
*
|
|
1373
|
+
* @example
|
|
1374
|
+
* const { data, loading, error } = useGetConnectionTagsQuery({
|
|
1375
|
+
* variables: {
|
|
1376
|
+
* input: // value for 'input'
|
|
1377
|
+
* },
|
|
1378
|
+
* });
|
|
1379
|
+
*/
|
|
1380
|
+
export declare function useGetConnectionTagsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetConnectionTagsQuery, Types.GetConnectionTagsQueryVariables> & ({
|
|
1381
|
+
variables: Types.GetConnectionTagsQueryVariables;
|
|
1382
|
+
skip?: boolean;
|
|
1383
|
+
} | {
|
|
1384
|
+
skip: boolean;
|
|
1385
|
+
})): ApolloReactHooks.useQuery.Result<Types.GetConnectionTagsQuery, Types.GetConnectionTagsQueryVariables, "complete" | "empty" | "streaming", Types.GetConnectionTagsQueryVariables>;
|
|
1386
|
+
export declare function useGetConnectionTagsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetConnectionTagsQuery, Types.GetConnectionTagsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetConnectionTagsQuery, Types.GetConnectionTagsQueryVariables, "complete" | "empty" | "streaming">;
|
|
1387
|
+
export declare function useGetConnectionTagsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetConnectionTagsQuery, Types.GetConnectionTagsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetConnectionTagsQuery, Types.GetConnectionTagsQueryVariables>;
|
|
1388
|
+
export declare function useGetConnectionTagsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetConnectionTagsQuery, Types.GetConnectionTagsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetConnectionTagsQuery | undefined, Types.GetConnectionTagsQueryVariables>;
|
|
1389
|
+
export type GetConnectionTagsQueryHookResult = ReturnType<typeof useGetConnectionTagsQuery>;
|
|
1390
|
+
export type GetConnectionTagsLazyQueryHookResult = ReturnType<typeof useGetConnectionTagsLazyQuery>;
|
|
1391
|
+
export type GetConnectionTagsSuspenseQueryHookResult = ReturnType<typeof useGetConnectionTagsSuspenseQuery>;
|
|
1392
|
+
export type GetConnectionTagsQueryResult = Apollo.QueryResult<Types.GetConnectionTagsQuery, Types.GetConnectionTagsQueryVariables>;
|
|
1393
|
+
export declare const GetConnectionsDocument: Apollo.DocumentNode;
|
|
1394
|
+
/**
|
|
1395
|
+
* __useGetConnectionsQuery__
|
|
1396
|
+
*
|
|
1397
|
+
* To run a query within a React component, call `useGetConnectionsQuery` and pass it any options that fit your needs.
|
|
1398
|
+
* When your component renders, `useGetConnectionsQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
1399
|
+
* you can use to render your UI.
|
|
1400
|
+
*
|
|
1401
|
+
* @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;
|
|
1402
|
+
*
|
|
1403
|
+
* @example
|
|
1404
|
+
* const { data, loading, error } = useGetConnectionsQuery({
|
|
1405
|
+
* variables: {
|
|
1406
|
+
* filter: // value for 'filter'
|
|
1407
|
+
* pagination: // value for 'pagination'
|
|
1408
|
+
* },
|
|
1409
|
+
* });
|
|
1410
|
+
*/
|
|
1411
|
+
export declare function useGetConnectionsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetConnectionsQuery, Types.GetConnectionsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetConnectionsQuery, Types.GetConnectionsQueryVariables, "complete" | "empty" | "streaming", Types.GetConnectionsQueryVariables>;
|
|
1412
|
+
export declare function useGetConnectionsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetConnectionsQuery, Types.GetConnectionsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetConnectionsQuery, Types.GetConnectionsQueryVariables, "complete" | "empty" | "streaming">;
|
|
1413
|
+
export declare function useGetConnectionsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetConnectionsQuery, Types.GetConnectionsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetConnectionsQuery, Types.GetConnectionsQueryVariables>;
|
|
1414
|
+
export declare function useGetConnectionsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetConnectionsQuery, Types.GetConnectionsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetConnectionsQuery | undefined, Types.GetConnectionsQueryVariables>;
|
|
1415
|
+
export type GetConnectionsQueryHookResult = ReturnType<typeof useGetConnectionsQuery>;
|
|
1416
|
+
export type GetConnectionsLazyQueryHookResult = ReturnType<typeof useGetConnectionsLazyQuery>;
|
|
1417
|
+
export type GetConnectionsSuspenseQueryHookResult = ReturnType<typeof useGetConnectionsSuspenseQuery>;
|
|
1418
|
+
export type GetConnectionsQueryResult = Apollo.QueryResult<Types.GetConnectionsQuery, Types.GetConnectionsQueryVariables>;
|
|
1419
|
+
export declare const GetConnectionsByProviderDocument: Apollo.DocumentNode;
|
|
1420
|
+
/**
|
|
1421
|
+
* __useGetConnectionsByProviderQuery__
|
|
1422
|
+
*
|
|
1423
|
+
* To run a query within a React component, call `useGetConnectionsByProviderQuery` and pass it any options that fit your needs.
|
|
1424
|
+
* When your component renders, `useGetConnectionsByProviderQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
1425
|
+
* you can use to render your UI.
|
|
1426
|
+
*
|
|
1427
|
+
* @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;
|
|
1428
|
+
*
|
|
1429
|
+
* @example
|
|
1430
|
+
* const { data, loading, error } = useGetConnectionsByProviderQuery({
|
|
1431
|
+
* variables: {
|
|
1432
|
+
* providerId: // value for 'providerId'
|
|
1433
|
+
* pagination: // value for 'pagination'
|
|
1434
|
+
* },
|
|
1435
|
+
* });
|
|
1436
|
+
*/
|
|
1437
|
+
export declare function useGetConnectionsByProviderQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetConnectionsByProviderQuery, Types.GetConnectionsByProviderQueryVariables> & ({
|
|
1438
|
+
variables: Types.GetConnectionsByProviderQueryVariables;
|
|
1439
|
+
skip?: boolean;
|
|
1440
|
+
} | {
|
|
1441
|
+
skip: boolean;
|
|
1442
|
+
})): ApolloReactHooks.useQuery.Result<Types.GetConnectionsByProviderQuery, Types.GetConnectionsByProviderQueryVariables, "complete" | "empty" | "streaming", Types.GetConnectionsByProviderQueryVariables>;
|
|
1443
|
+
export declare function useGetConnectionsByProviderLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetConnectionsByProviderQuery, Types.GetConnectionsByProviderQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetConnectionsByProviderQuery, Types.GetConnectionsByProviderQueryVariables, "complete" | "empty" | "streaming">;
|
|
1444
|
+
export declare function useGetConnectionsByProviderSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetConnectionsByProviderQuery, Types.GetConnectionsByProviderQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetConnectionsByProviderQuery, Types.GetConnectionsByProviderQueryVariables>;
|
|
1445
|
+
export declare function useGetConnectionsByProviderSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetConnectionsByProviderQuery, Types.GetConnectionsByProviderQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetConnectionsByProviderQuery | undefined, Types.GetConnectionsByProviderQueryVariables>;
|
|
1446
|
+
export type GetConnectionsByProviderQueryHookResult = ReturnType<typeof useGetConnectionsByProviderQuery>;
|
|
1447
|
+
export type GetConnectionsByProviderLazyQueryHookResult = ReturnType<typeof useGetConnectionsByProviderLazyQuery>;
|
|
1448
|
+
export type GetConnectionsByProviderSuspenseQueryHookResult = ReturnType<typeof useGetConnectionsByProviderSuspenseQuery>;
|
|
1449
|
+
export type GetConnectionsByProviderQueryResult = Apollo.QueryResult<Types.GetConnectionsByProviderQuery, Types.GetConnectionsByProviderQueryVariables>;
|
|
1450
|
+
export declare const GetIntegrationLogsDocument: Apollo.DocumentNode;
|
|
1451
|
+
/**
|
|
1452
|
+
* __useGetIntegrationLogsQuery__
|
|
1453
|
+
*
|
|
1454
|
+
* To run a query within a React component, call `useGetIntegrationLogsQuery` and pass it any options that fit your needs.
|
|
1455
|
+
* When your component renders, `useGetIntegrationLogsQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
1456
|
+
* you can use to render your UI.
|
|
1457
|
+
*
|
|
1458
|
+
* @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;
|
|
1459
|
+
*
|
|
1460
|
+
* @example
|
|
1461
|
+
* const { data, loading, error } = useGetIntegrationLogsQuery({
|
|
1462
|
+
* variables: {
|
|
1463
|
+
* filter: // value for 'filter'
|
|
1464
|
+
* pagination: // value for 'pagination'
|
|
1465
|
+
* },
|
|
1466
|
+
* });
|
|
1467
|
+
*/
|
|
1468
|
+
export declare function useGetIntegrationLogsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetIntegrationLogsQuery, Types.GetIntegrationLogsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetIntegrationLogsQuery, Types.GetIntegrationLogsQueryVariables, "complete" | "empty" | "streaming", Types.GetIntegrationLogsQueryVariables>;
|
|
1469
|
+
export declare function useGetIntegrationLogsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetIntegrationLogsQuery, Types.GetIntegrationLogsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetIntegrationLogsQuery, Types.GetIntegrationLogsQueryVariables, "complete" | "empty" | "streaming">;
|
|
1470
|
+
export declare function useGetIntegrationLogsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetIntegrationLogsQuery, Types.GetIntegrationLogsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetIntegrationLogsQuery, Types.GetIntegrationLogsQueryVariables>;
|
|
1471
|
+
export declare function useGetIntegrationLogsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetIntegrationLogsQuery, Types.GetIntegrationLogsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetIntegrationLogsQuery | undefined, Types.GetIntegrationLogsQueryVariables>;
|
|
1472
|
+
export type GetIntegrationLogsQueryHookResult = ReturnType<typeof useGetIntegrationLogsQuery>;
|
|
1473
|
+
export type GetIntegrationLogsLazyQueryHookResult = ReturnType<typeof useGetIntegrationLogsLazyQuery>;
|
|
1474
|
+
export type GetIntegrationLogsSuspenseQueryHookResult = ReturnType<typeof useGetIntegrationLogsSuspenseQuery>;
|
|
1475
|
+
export type GetIntegrationLogsQueryResult = Apollo.QueryResult<Types.GetIntegrationLogsQuery, Types.GetIntegrationLogsQueryVariables>;
|
|
1476
|
+
export declare const GetProviderDocument: Apollo.DocumentNode;
|
|
1477
|
+
/**
|
|
1478
|
+
* __useGetProviderQuery__
|
|
1479
|
+
*
|
|
1480
|
+
* To run a query within a React component, call `useGetProviderQuery` and pass it any options that fit your needs.
|
|
1481
|
+
* When your component renders, `useGetProviderQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
1482
|
+
* you can use to render your UI.
|
|
1483
|
+
*
|
|
1484
|
+
* @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;
|
|
1485
|
+
*
|
|
1486
|
+
* @example
|
|
1487
|
+
* const { data, loading, error } = useGetProviderQuery({
|
|
1488
|
+
* variables: {
|
|
1489
|
+
* id: // value for 'id'
|
|
1490
|
+
* },
|
|
1491
|
+
* });
|
|
1492
|
+
*/
|
|
1493
|
+
export declare function useGetProviderQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetProviderQuery, Types.GetProviderQueryVariables> & ({
|
|
1494
|
+
variables: Types.GetProviderQueryVariables;
|
|
1495
|
+
skip?: boolean;
|
|
1496
|
+
} | {
|
|
1497
|
+
skip: boolean;
|
|
1498
|
+
})): ApolloReactHooks.useQuery.Result<Types.GetProviderQuery, Types.GetProviderQueryVariables, "complete" | "empty" | "streaming", Types.GetProviderQueryVariables>;
|
|
1499
|
+
export declare function useGetProviderLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetProviderQuery, Types.GetProviderQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetProviderQuery, Types.GetProviderQueryVariables, "complete" | "empty" | "streaming">;
|
|
1500
|
+
export declare function useGetProviderSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetProviderQuery, Types.GetProviderQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetProviderQuery, Types.GetProviderQueryVariables>;
|
|
1501
|
+
export declare function useGetProviderSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetProviderQuery, Types.GetProviderQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetProviderQuery | undefined, Types.GetProviderQueryVariables>;
|
|
1502
|
+
export type GetProviderQueryHookResult = ReturnType<typeof useGetProviderQuery>;
|
|
1503
|
+
export type GetProviderLazyQueryHookResult = ReturnType<typeof useGetProviderLazyQuery>;
|
|
1504
|
+
export type GetProviderSuspenseQueryHookResult = ReturnType<typeof useGetProviderSuspenseQuery>;
|
|
1505
|
+
export type GetProviderQueryResult = Apollo.QueryResult<Types.GetProviderQuery, Types.GetProviderQueryVariables>;
|
|
1506
|
+
export declare const GetProviderByKeyDocument: Apollo.DocumentNode;
|
|
1507
|
+
/**
|
|
1508
|
+
* __useGetProviderByKeyQuery__
|
|
1509
|
+
*
|
|
1510
|
+
* To run a query within a React component, call `useGetProviderByKeyQuery` and pass it any options that fit your needs.
|
|
1511
|
+
* When your component renders, `useGetProviderByKeyQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
1512
|
+
* you can use to render your UI.
|
|
1513
|
+
*
|
|
1514
|
+
* @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;
|
|
1515
|
+
*
|
|
1516
|
+
* @example
|
|
1517
|
+
* const { data, loading, error } = useGetProviderByKeyQuery({
|
|
1518
|
+
* variables: {
|
|
1519
|
+
* key: // value for 'key'
|
|
1520
|
+
* },
|
|
1521
|
+
* });
|
|
1522
|
+
*/
|
|
1523
|
+
export declare function useGetProviderByKeyQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetProviderByKeyQuery, Types.GetProviderByKeyQueryVariables> & ({
|
|
1524
|
+
variables: Types.GetProviderByKeyQueryVariables;
|
|
1525
|
+
skip?: boolean;
|
|
1526
|
+
} | {
|
|
1527
|
+
skip: boolean;
|
|
1528
|
+
})): ApolloReactHooks.useQuery.Result<Types.GetProviderByKeyQuery, Types.GetProviderByKeyQueryVariables, "complete" | "empty" | "streaming", Types.GetProviderByKeyQueryVariables>;
|
|
1529
|
+
export declare function useGetProviderByKeyLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetProviderByKeyQuery, Types.GetProviderByKeyQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetProviderByKeyQuery, Types.GetProviderByKeyQueryVariables, "complete" | "empty" | "streaming">;
|
|
1530
|
+
export declare function useGetProviderByKeySuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetProviderByKeyQuery, Types.GetProviderByKeyQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetProviderByKeyQuery, Types.GetProviderByKeyQueryVariables>;
|
|
1531
|
+
export declare function useGetProviderByKeySuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetProviderByKeyQuery, Types.GetProviderByKeyQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetProviderByKeyQuery | undefined, Types.GetProviderByKeyQueryVariables>;
|
|
1532
|
+
export type GetProviderByKeyQueryHookResult = ReturnType<typeof useGetProviderByKeyQuery>;
|
|
1533
|
+
export type GetProviderByKeyLazyQueryHookResult = ReturnType<typeof useGetProviderByKeyLazyQuery>;
|
|
1534
|
+
export type GetProviderByKeySuspenseQueryHookResult = ReturnType<typeof useGetProviderByKeySuspenseQuery>;
|
|
1535
|
+
export type GetProviderByKeyQueryResult = Apollo.QueryResult<Types.GetProviderByKeyQuery, Types.GetProviderByKeyQueryVariables>;
|
|
1536
|
+
export declare const GetProviderCatalogDocument: Apollo.DocumentNode;
|
|
1537
|
+
/**
|
|
1538
|
+
* __useGetProviderCatalogQuery__
|
|
1539
|
+
*
|
|
1540
|
+
* To run a query within a React component, call `useGetProviderCatalogQuery` and pass it any options that fit your needs.
|
|
1541
|
+
* When your component renders, `useGetProviderCatalogQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
1542
|
+
* you can use to render your UI.
|
|
1543
|
+
*
|
|
1544
|
+
* @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;
|
|
1545
|
+
*
|
|
1546
|
+
* @example
|
|
1547
|
+
* const { data, loading, error } = useGetProviderCatalogQuery({
|
|
1548
|
+
* variables: {
|
|
1549
|
+
* pagination: // value for 'pagination'
|
|
1550
|
+
* },
|
|
1551
|
+
* });
|
|
1552
|
+
*/
|
|
1553
|
+
export declare function useGetProviderCatalogQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetProviderCatalogQuery, Types.GetProviderCatalogQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetProviderCatalogQuery, Types.GetProviderCatalogQueryVariables, "complete" | "empty" | "streaming", Types.GetProviderCatalogQueryVariables>;
|
|
1554
|
+
export declare function useGetProviderCatalogLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetProviderCatalogQuery, Types.GetProviderCatalogQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetProviderCatalogQuery, Types.GetProviderCatalogQueryVariables, "complete" | "empty" | "streaming">;
|
|
1555
|
+
export declare function useGetProviderCatalogSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetProviderCatalogQuery, Types.GetProviderCatalogQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetProviderCatalogQuery, Types.GetProviderCatalogQueryVariables>;
|
|
1556
|
+
export declare function useGetProviderCatalogSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetProviderCatalogQuery, Types.GetProviderCatalogQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetProviderCatalogQuery | undefined, Types.GetProviderCatalogQueryVariables>;
|
|
1557
|
+
export type GetProviderCatalogQueryHookResult = ReturnType<typeof useGetProviderCatalogQuery>;
|
|
1558
|
+
export type GetProviderCatalogLazyQueryHookResult = ReturnType<typeof useGetProviderCatalogLazyQuery>;
|
|
1559
|
+
export type GetProviderCatalogSuspenseQueryHookResult = ReturnType<typeof useGetProviderCatalogSuspenseQuery>;
|
|
1560
|
+
export type GetProviderCatalogQueryResult = Apollo.QueryResult<Types.GetProviderCatalogQuery, Types.GetProviderCatalogQueryVariables>;
|
|
1561
|
+
export declare const GetProvidersDocument: Apollo.DocumentNode;
|
|
1562
|
+
/**
|
|
1563
|
+
* __useGetProvidersQuery__
|
|
1564
|
+
*
|
|
1565
|
+
* To run a query within a React component, call `useGetProvidersQuery` and pass it any options that fit your needs.
|
|
1566
|
+
* When your component renders, `useGetProvidersQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
1567
|
+
* you can use to render your UI.
|
|
1568
|
+
*
|
|
1569
|
+
* @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;
|
|
1570
|
+
*
|
|
1571
|
+
* @example
|
|
1572
|
+
* const { data, loading, error } = useGetProvidersQuery({
|
|
1573
|
+
* variables: {
|
|
1574
|
+
* filter: // value for 'filter'
|
|
1575
|
+
* pagination: // value for 'pagination'
|
|
1576
|
+
* },
|
|
1577
|
+
* });
|
|
1578
|
+
*/
|
|
1579
|
+
export declare function useGetProvidersQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetProvidersQuery, Types.GetProvidersQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetProvidersQuery, Types.GetProvidersQueryVariables, "complete" | "empty" | "streaming", Types.GetProvidersQueryVariables>;
|
|
1580
|
+
export declare function useGetProvidersLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetProvidersQuery, Types.GetProvidersQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetProvidersQuery, Types.GetProvidersQueryVariables, "complete" | "empty" | "streaming">;
|
|
1581
|
+
export declare function useGetProvidersSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetProvidersQuery, Types.GetProvidersQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetProvidersQuery, Types.GetProvidersQueryVariables>;
|
|
1582
|
+
export declare function useGetProvidersSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetProvidersQuery, Types.GetProvidersQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetProvidersQuery | undefined, Types.GetProvidersQueryVariables>;
|
|
1583
|
+
export type GetProvidersQueryHookResult = ReturnType<typeof useGetProvidersQuery>;
|
|
1584
|
+
export type GetProvidersLazyQueryHookResult = ReturnType<typeof useGetProvidersLazyQuery>;
|
|
1585
|
+
export type GetProvidersSuspenseQueryHookResult = ReturnType<typeof useGetProvidersSuspenseQuery>;
|
|
1586
|
+
export type GetProvidersQueryResult = Apollo.QueryResult<Types.GetProvidersQuery, Types.GetProvidersQueryVariables>;
|
|
1587
|
+
export declare const GetVaultSecretsForIntegrationsDocument: Apollo.DocumentNode;
|
|
1588
|
+
/**
|
|
1589
|
+
* __useGetVaultSecretsForIntegrationsQuery__
|
|
1590
|
+
*
|
|
1591
|
+
* To run a query within a React component, call `useGetVaultSecretsForIntegrationsQuery` and pass it any options that fit your needs.
|
|
1592
|
+
* When your component renders, `useGetVaultSecretsForIntegrationsQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
1593
|
+
* you can use to render your UI.
|
|
1594
|
+
*
|
|
1595
|
+
* @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;
|
|
1596
|
+
*
|
|
1597
|
+
* @example
|
|
1598
|
+
* const { data, loading, error } = useGetVaultSecretsForIntegrationsQuery({
|
|
1599
|
+
* variables: {
|
|
1600
|
+
* vaultId: // value for 'vaultId'
|
|
1601
|
+
* filter: // value for 'filter'
|
|
1602
|
+
* pagination: // value for 'pagination'
|
|
1603
|
+
* },
|
|
1604
|
+
* });
|
|
1605
|
+
*/
|
|
1606
|
+
export declare function useGetVaultSecretsForIntegrationsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetVaultSecretsForIntegrationsQuery, Types.GetVaultSecretsForIntegrationsQueryVariables> & ({
|
|
1607
|
+
variables: Types.GetVaultSecretsForIntegrationsQueryVariables;
|
|
1608
|
+
skip?: boolean;
|
|
1609
|
+
} | {
|
|
1610
|
+
skip: boolean;
|
|
1611
|
+
})): ApolloReactHooks.useQuery.Result<Types.GetVaultSecretsForIntegrationsQuery, Types.GetVaultSecretsForIntegrationsQueryVariables, "complete" | "empty" | "streaming", Types.GetVaultSecretsForIntegrationsQueryVariables>;
|
|
1612
|
+
export declare function useGetVaultSecretsForIntegrationsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetVaultSecretsForIntegrationsQuery, Types.GetVaultSecretsForIntegrationsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetVaultSecretsForIntegrationsQuery, Types.GetVaultSecretsForIntegrationsQueryVariables, "complete" | "empty" | "streaming">;
|
|
1613
|
+
export declare function useGetVaultSecretsForIntegrationsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetVaultSecretsForIntegrationsQuery, Types.GetVaultSecretsForIntegrationsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetVaultSecretsForIntegrationsQuery, Types.GetVaultSecretsForIntegrationsQueryVariables>;
|
|
1614
|
+
export declare function useGetVaultSecretsForIntegrationsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetVaultSecretsForIntegrationsQuery, Types.GetVaultSecretsForIntegrationsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetVaultSecretsForIntegrationsQuery | undefined, Types.GetVaultSecretsForIntegrationsQueryVariables>;
|
|
1615
|
+
export type GetVaultSecretsForIntegrationsQueryHookResult = ReturnType<typeof useGetVaultSecretsForIntegrationsQuery>;
|
|
1616
|
+
export type GetVaultSecretsForIntegrationsLazyQueryHookResult = ReturnType<typeof useGetVaultSecretsForIntegrationsLazyQuery>;
|
|
1617
|
+
export type GetVaultSecretsForIntegrationsSuspenseQueryHookResult = ReturnType<typeof useGetVaultSecretsForIntegrationsSuspenseQuery>;
|
|
1618
|
+
export type GetVaultSecretsForIntegrationsQueryResult = Apollo.QueryResult<Types.GetVaultSecretsForIntegrationsQuery, Types.GetVaultSecretsForIntegrationsQueryVariables>;
|
|
1619
|
+
export declare const GetVaultsForIntegrationsDocument: Apollo.DocumentNode;
|
|
1620
|
+
/**
|
|
1621
|
+
* __useGetVaultsForIntegrationsQuery__
|
|
1622
|
+
*
|
|
1623
|
+
* To run a query within a React component, call `useGetVaultsForIntegrationsQuery` and pass it any options that fit your needs.
|
|
1624
|
+
* When your component renders, `useGetVaultsForIntegrationsQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
1625
|
+
* you can use to render your UI.
|
|
1626
|
+
*
|
|
1627
|
+
* @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;
|
|
1628
|
+
*
|
|
1629
|
+
* @example
|
|
1630
|
+
* const { data, loading, error } = useGetVaultsForIntegrationsQuery({
|
|
1631
|
+
* variables: {
|
|
1632
|
+
* filter: // value for 'filter'
|
|
1633
|
+
* pagination: // value for 'pagination'
|
|
1634
|
+
* },
|
|
1635
|
+
* });
|
|
1636
|
+
*/
|
|
1637
|
+
export declare function useGetVaultsForIntegrationsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetVaultsForIntegrationsQuery, Types.GetVaultsForIntegrationsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetVaultsForIntegrationsQuery, Types.GetVaultsForIntegrationsQueryVariables, "complete" | "empty" | "streaming", Types.GetVaultsForIntegrationsQueryVariables>;
|
|
1638
|
+
export declare function useGetVaultsForIntegrationsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetVaultsForIntegrationsQuery, Types.GetVaultsForIntegrationsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetVaultsForIntegrationsQuery, Types.GetVaultsForIntegrationsQueryVariables, "complete" | "empty" | "streaming">;
|
|
1639
|
+
export declare function useGetVaultsForIntegrationsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetVaultsForIntegrationsQuery, Types.GetVaultsForIntegrationsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetVaultsForIntegrationsQuery, Types.GetVaultsForIntegrationsQueryVariables>;
|
|
1640
|
+
export declare function useGetVaultsForIntegrationsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetVaultsForIntegrationsQuery, Types.GetVaultsForIntegrationsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetVaultsForIntegrationsQuery | undefined, Types.GetVaultsForIntegrationsQueryVariables>;
|
|
1641
|
+
export type GetVaultsForIntegrationsQueryHookResult = ReturnType<typeof useGetVaultsForIntegrationsQuery>;
|
|
1642
|
+
export type GetVaultsForIntegrationsLazyQueryHookResult = ReturnType<typeof useGetVaultsForIntegrationsLazyQuery>;
|
|
1643
|
+
export type GetVaultsForIntegrationsSuspenseQueryHookResult = ReturnType<typeof useGetVaultsForIntegrationsSuspenseQuery>;
|
|
1644
|
+
export type GetVaultsForIntegrationsQueryResult = Apollo.QueryResult<Types.GetVaultsForIntegrationsQuery, Types.GetVaultsForIntegrationsQueryVariables>;
|
|
1645
|
+
//# sourceMappingURL=wspace-operations.d.ts.map
|