@sipgate/integration-bridge 1.0.35 → 1.0.38

package/dist/swagger/openapi-spec.js

@@ -0,0 +1,787 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openApiSpec = void 0;
+exports.openApiSpec = {
+    openapi: '3.0.3',
+    info: {
+        title: 'Integration Bridge API',
+        description: 'API provided by the sipgate Integration Bridge Framework. Each bridge implements a subset of these endpoints via the Adapter interface.\n\nUse the **Authorize** button to set your `x-provider-key`. Configure additional global headers (Provider URL, User ID, Locale) in the **Global Headers** bar above.',
+        version: '1.0.36',
+    },
+    tags: [
+        { name: 'Contacts', description: 'Contact CRUD and streaming' },
+        { name: 'Entities', description: 'Integration entity lookup' },
+        {
+            name: 'Call Events',
+            description: 'Legacy call event handling (deprecated)',
+        },
+        { name: 'Call Log', description: 'Call log management' },
+        { name: 'Lifecycle', description: 'Connection lifecycle events' },
+        { name: 'OAuth2', description: 'OAuth2 authentication flow' },
+        { name: 'Account', description: 'Account and token management' },
+        { name: 'Webhooks', description: 'Webhook handling' },
+        { name: 'Tasks', description: 'Task and follow-up management' },
+        { name: 'Health', description: 'Health check' },
+    ],
+    security: [{ providerKey: [] }],
+    paths: {
+        '/contacts': {
+            get: {
+                tags: ['Contacts'],
+                summary: 'Get all contacts',
+                description: 'Returns all contacts from the integration provider. Uses a stale-while-revalidate cache with a 5s timeout — may return an empty array with X-Fetching-State: pending if the fetch is slow.',
+                responses: {
+                    '200': {
+                        description: 'List of contacts',
+                        headers: {
+                            'X-Fetching-State': {
+                                schema: { type: 'string', enum: ['pending'] },
+                                description: 'Set to "pending" if contacts are still being fetched',
+                            },
+                            'X-Provider-Key': {
+                                schema: { type: 'string' },
+                                description: 'Refreshed API key (if token refresh is supported)',
+                            },
+                        },
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    type: 'array',
+                                    items: { $ref: '#/components/schemas/Contact' },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+            post: {
+                tags: ['Contacts'],
+                summary: 'Create a contact',
+                requestBody: {
+                    required: true,
+                    content: {
+                        'application/json': {
+                            schema: { $ref: '#/components/schemas/ContactTemplate' },
+                        },
+                    },
+                },
+                responses: {
+                    '200': {
+                        description: 'Created contact',
+                        content: {
+                            'application/json': {
+                                schema: { $ref: '#/components/schemas/Contact' },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        '/contacts/{id}': {
+            get: {
+                tags: ['Contacts'],
+                summary: 'Get a single contact',
+                parameters: [
+                    {
+                        name: 'id',
+                        in: 'path',
+                        required: true,
+                        schema: { type: 'string' },
+                    },
+                    {
+                        name: 'type',
+                        in: 'query',
+                        required: true,
+                        schema: { $ref: '#/components/schemas/IntegrationEntityType' },
+                        description: 'Contact entity type',
+                    },
+                ],
+                responses: {
+                    '200': {
+                        description: 'Contact',
+                        content: {
+                            'application/json': {
+                                schema: { $ref: '#/components/schemas/Contact' },
+                            },
+                        },
+                    },
+                },
+            },
+            put: {
+                tags: ['Contacts'],
+                summary: 'Update a contact',
+                parameters: [
+                    {
+                        name: 'id',
+                        in: 'path',
+                        required: true,
+                        schema: { type: 'string' },
+                    },
+                ],
+                requestBody: {
+                    required: true,
+                    content: {
+                        'application/json': {
+                            schema: { $ref: '#/components/schemas/ContactTemplate' },
+                        },
+                    },
+                },
+                responses: {
+                    '200': {
+                        description: 'Updated contact',
+                        content: {
+                            'application/json': {
+                                schema: { $ref: '#/components/schemas/Contact' },
+                            },
+                        },
+                    },
+                },
+            },
+            delete: {
+                tags: ['Contacts'],
+                summary: 'Delete a contact',
+                parameters: [
+                    {
+                        name: 'id',
+                        in: 'path',
+                        required: true,
+                        schema: { type: 'string' },
+                    },
+                ],
+                responses: {
+                    '200': { description: 'Contact deleted' },
+                },
+            },
+        },
+        '/contacts/stream': {
+            post: {
+                tags: ['Contacts'],
+                summary: 'Stream contacts via PubSub',
+                description: 'Triggers async contact streaming via Google PubSub. Returns immediately with a timestamp; contacts are published in batches.',
+                responses: {
+                    '200': {
+                        description: 'Streaming started',
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    type: 'object',
+                                    properties: { timestamp: { type: 'number' } },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        '/contacts/{id}/entities': {
+            get: {
+                tags: ['Contacts'],
+                summary: 'Get entities for a contact',
+                parameters: [
+                    {
+                        name: 'id',
+                        in: 'path',
+                        required: true,
+                        schema: { type: 'string' },
+                        description: 'Contact ID',
+                    },
+                ],
+                responses: {
+                    '200': {
+                        description: 'List of entities related to the contact',
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    type: 'array',
+                                    items: {
+                                        $ref: '#/components/schemas/LabeledIntegrationEntity',
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        '/entity/{type}/{id}': {
+            get: {
+                tags: ['Entities'],
+                summary: 'Get a single entity',
+                parameters: [
+                    {
+                        name: 'type',
+                        in: 'path',
+                        required: true,
+                        schema: { $ref: '#/components/schemas/IntegrationEntityType' },
+                    },
+                    {
+                        name: 'id',
+                        in: 'path',
+                        required: true,
+                        schema: { type: 'string' },
+                    },
+                ],
+                responses: {
+                    '200': {
+                        description: 'Entity',
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    $ref: '#/components/schemas/LabeledIntegrationEntity',
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        '/events/calls': {
+            post: {
+                tags: ['Call Events'],
+                summary: 'Handle call event (deprecated)',
+                deprecated: true,
+                description: 'Use PUT /call-log instead.',
+                requestBody: {
+                    required: true,
+                    content: {
+                        'application/json': {
+                            schema: { $ref: '#/components/schemas/CallEvent' },
+                        },
+                    },
+                },
+                responses: {
+                    '200': {
+                        description: 'Call event reference ID',
+                        content: {
+                            'application/json': { schema: { type: 'string' } },
+                        },
+                    },
+                },
+            },
+        },
+        '/events/calls/{id}': {
+            put: {
+                tags: ['Call Events'],
+                summary: 'Update call event (deprecated)',
+                deprecated: true,
+                description: 'Use PUT /call-log instead.',
+                parameters: [
+                    {
+                        name: 'id',
+                        in: 'path',
+                        required: true,
+                        schema: { type: 'string' },
+                    },
+                ],
+                requestBody: {
+                    required: true,
+                    content: {
+                        'application/json': {
+                            schema: { $ref: '#/components/schemas/CallEvent' },
+                        },
+                    },
+                },
+                responses: {
+                    '200': { description: 'Call event updated' },
+                },
+            },
+        },
+        '/events/connected': {
+            post: {
+                tags: ['Lifecycle'],
+                summary: 'Handle connected event',
+                description: 'Called when a user connects the integration.',
+                responses: {
+                    '200': { description: 'Connected event handled' },
+                },
+            },
+        },
+        '/events/disconnected': {
+            post: {
+                tags: ['Lifecycle'],
+                summary: 'Handle disconnected event',
+                description: 'Called when a user disconnects the integration.',
+                responses: {
+                    '200': { description: 'Disconnected event handled' },
+                },
+            },
+        },
+        '/call-log': {
+            put: {
+                tags: ['Call Log'],
+                summary: 'Create or update call logs for entities',
+                requestBody: {
+                    required: true,
+                    content: {
+                        'application/json': {
+                            schema: {
+                                $ref: '#/components/schemas/CallEventWithIntegrationEntities',
+                            },
+                        },
+                    },
+                },
+                responses: {
+                    '200': {
+                        description: 'Logged entities',
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    type: 'array',
+                                    items: {
+                                        $ref: '#/components/schemas/LoggedIntegrationEntity',
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        '/call-log/phoneNumber': {
+            put: {
+                tags: ['Call Log'],
+                summary: 'Create call log for phone number',
+                requestBody: {
+                    required: true,
+                    content: {
+                        'application/json': {
+                            schema: { $ref: '#/components/schemas/CallEvent' },
+                        },
+                    },
+                },
+                responses: {
+                    '200': {
+                        description: 'Logged entity or null',
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    nullable: true,
+                                    $ref: '#/components/schemas/LoggedIntegrationEntity',
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        '/call-log-metadata': {
+            get: {
+                tags: ['Call Log'],
+                summary: 'Get call log metadata',
+                responses: {
+                    '200': {
+                        description: 'Call log options',
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    $ref: '#/components/schemas/IntegrationDefinedOptions',
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        '/health': {
+            get: {
+                tags: ['Health'],
+                summary: 'Health check',
+                description: 'Returns 200 if the service is healthy. No authentication required.',
+                security: [],
+                responses: {
+                    '200': { description: 'OK' },
+                },
+            },
+        },
+        '/validate-token': {
+            get: {
+                tags: ['Account'],
+                summary: 'Validate provider token',
+                responses: {
+                    '200': {
+                        description: 'Token is valid',
+                        content: {
+                            'text/plain': { schema: { type: 'string', example: 'OK' } },
+                        },
+                    },
+                    '401': { description: 'Token is not valid' },
+                },
+            },
+        },
+        '/oauth2/redirect': {
+            get: {
+                tags: ['OAuth2'],
+                summary: 'Get OAuth2 redirect URL',
+                description: 'Returns the URL to redirect the user to for OAuth2 authorization.',
+                security: [],
+                responses: {
+                    '200': {
+                        description: 'Redirect URL',
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    type: 'object',
+                                    properties: { redirectUrl: { type: 'string' } },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        '/oauth2/callback': {
+            get: {
+                tags: ['OAuth2'],
+                summary: 'OAuth2 callback (browser redirect)',
+                description: 'Handles the OAuth2 callback and redirects the browser to OAUTH2_REDIRECT_URL with the token.',
+                security: [],
+                parameters: [
+                    {
+                        name: 'code',
+                        in: 'query',
+                        schema: { type: 'string' },
+                        description: 'OAuth2 authorization code',
+                    },
+                ],
+                responses: {
+                    '302': {
+                        description: 'Redirect to OAUTH2_REDIRECT_URL with token params',
+                    },
+                },
+            },
+        },
+        '/oauth2/token': {
+            get: {
+                tags: ['OAuth2'],
+                summary: 'OAuth2 token exchange (JSON)',
+                description: 'Handles the OAuth2 callback and returns the token as JSON instead of redirecting.',
+                security: [],
+                parameters: [
+                    {
+                        name: 'code',
+                        in: 'query',
+                        schema: { type: 'string' },
+                        description: 'OAuth2 authorization code',
+                    },
+                ],
+                responses: {
+                    '200': {
+                        description: 'OAuth2 credentials',
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    type: 'object',
+                                    properties: {
+                                        apiKey: { type: 'string' },
+                                        apiUrl: { type: 'string' },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        '/account/id': {
+            get: {
+                tags: ['Account'],
+                summary: 'Get account ID',
+                responses: {
+                    '200': {
+                        description: 'Account ID',
+                        content: {
+                            'application/json': { schema: { type: 'string' } },
+                        },
+                    },
+                },
+            },
+        },
+        '/webhook': {
+            post: {
+                tags: ['Webhooks'],
+                summary: 'Handle webhook',
+                description: 'Receives webhook events from the integration provider, verifies the request, and publishes events via PubSub.',
+                security: [],
+                requestBody: {
+                    required: true,
+                    content: {
+                        'application/json': { schema: { type: 'object' } },
+                    },
+                },
+                responses: {
+                    '200': { description: 'Webhook processed' },
+                    '403': { description: 'Webhook verification failed' },
+                },
+            },
+        },
+        '/tasks/{id}': {
+            get: {
+                tags: ['Tasks'],
+                summary: 'Get task by ID',
+                parameters: [
+                    {
+                        name: 'id',
+                        in: 'path',
+                        required: true,
+                        schema: { type: 'string' },
+                    },
+                ],
+                responses: {
+                    '200': {
+                        description: 'Task',
+                        content: {
+                            'application/json': {
+                                schema: { $ref: '#/components/schemas/Task' },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        '/tasks': {
+            post: {
+                tags: ['Tasks'],
+                summary: 'Create follow-up task',
+                requestBody: {
+                    required: true,
+                    content: {
+                        'application/json': {
+                            schema: {
+                                $ref: '#/components/schemas/FollowUpWithIntegrationEntities',
+                            },
+                        },
+                    },
+                },
+                responses: {
+                    '200': {
+                        description: 'Created follow-up ID',
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    type: 'object',
+                                    properties: { followUpId: { type: 'string' } },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        '/task-metadata': {
+            get: {
+                tags: ['Tasks'],
+                summary: 'Get task metadata',
+                responses: {
+                    '200': {
+                        description: 'Task options',
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    $ref: '#/components/schemas/IntegrationDefinedOptions',
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    },
+    components: {
+        securitySchemes: {
+            providerKey: {
+                type: 'apiKey',
+                in: 'header',
+                name: 'x-provider-key',
+                description: 'API key or OAuth token for the integration provider',
+            },
+        },
+        schemas: {
+            PhoneNumberLabel: {
+                type: 'string',
+                enum: [
+                    'WORK', 'MOBILE', 'HOME', 'HOMEFAX', 'WORKFAX', 'OTHERFAX',
+                    'PAGER', 'WORKMOBILE', 'WORKPAGER', 'MAIN', 'GOOGLEVOICE',
+                    'OTHER', 'DIRECTDIAL',
+                ],
+            },
+            PhoneNumber: {
+                type: 'object',
+                required: ['label', 'phoneNumber'],
+                properties: {
+                    label: { type: 'string', description: 'PhoneNumberLabel or custom string' },
+                    phoneNumber: { type: 'string', example: '+4921111111111' },
+                },
+            },
+            ContactScope: {
+                type: 'string',
+                enum: ['PRIVATE', 'SHARED', 'INTERNAL'],
+            },
+            IntegrationEntityType: {
+                type: 'string',
+                enum: [
+                    'contacts', 'deals', 'companies', 'tickets', 'leads', 'accounts',
+                    'opportunities', 'cases', 'building_objects', 'building_objects_leads',
+                    'contacts_folder', 'users', 'tasks',
+                ],
+            },
+            ContactTemplate: {
+                type: 'object',
+                required: ['phoneNumbers'],
+                properties: {
+                    name: { type: 'string', nullable: true },
+                    firstName: { type: 'string', nullable: true },
+                    lastName: { type: 'string', nullable: true },
+                    email: { type: 'string', nullable: true },
+                    organization: { type: 'string', nullable: true },
+                    phoneNumbers: {
+                        type: 'array',
+                        items: { $ref: '#/components/schemas/PhoneNumber' },
+                    },
+                    type: { $ref: '#/components/schemas/IntegrationEntityType' },
+                    scope: { $ref: '#/components/schemas/ContactScope' },
+                },
+            },
+            Contact: {
+                allOf: [
+                    { $ref: '#/components/schemas/ContactTemplate' },
+                    {
+                        type: 'object',
+                        required: ['id'],
+                        properties: {
+                            id: { type: 'string' },
+                            contactUrl: { type: 'string', nullable: true },
+                            avatarUrl: { type: 'string', nullable: true },
+                            readonly: { type: 'boolean' },
+                            relatesTo: {
+                                type: 'array',
+                                items: { $ref: '#/components/schemas/IntegrationEntity' },
+                            },
+                        },
+                    },
+                ],
+            },
+            IntegrationEntity: {
+                type: 'object',
+                required: ['id', 'type', 'source'],
+                properties: {
+                    id: { type: 'string' },
+                    type: { $ref: '#/components/schemas/IntegrationEntityType' },
+                    source: { type: 'string' },
+                },
+            },
+            LabeledIntegrationEntity: {
+                allOf: [
+                    { $ref: '#/components/schemas/IntegrationEntity' },
+                    {
+                        type: 'object',
+                        required: ['label'],
+                        properties: { label: { type: 'string' } },
+                    },
+                ],
+            },
+            LoggedIntegrationEntity: {
+                allOf: [
+                    { $ref: '#/components/schemas/IntegrationEntity' },
+                    {
+                        type: 'object',
+                        required: ['logId'],
+                        properties: { logId: { type: 'string' } },
+                    },
+                ],
+            },
+            CallDirection: { type: 'string', enum: ['IN', 'OUT'] },
+            CallParticipantType: { type: 'string', enum: ['local', 'remote'] },
+            CallState: {
+                type: 'string',
+                enum: ['BUSY', 'CONNECTED', 'MISSED', 'NOT_FOUND'],
+            },
+            CallParticipant: {
+                type: 'object',
+                required: ['type', 'phoneNumber'],
+                properties: {
+                    type: { $ref: '#/components/schemas/CallParticipantType' },
+                    phoneNumber: { type: 'string' },
+                },
+            },
+            CallEvent: {
+                type: 'object',
+                required: ['id', 'startTime', 'direction', 'participants', 'note', 'state'],
+                properties: {
+                    id: { type: 'string' },
+                    startTime: { type: 'number' },
+                    endTime: { type: 'number' },
+                    direction: { $ref: '#/components/schemas/CallDirection' },
+                    participants: {
+                        type: 'array',
+                        items: { $ref: '#/components/schemas/CallParticipant' },
+                    },
+                    note: { type: 'string' },
+                    state: { $ref: '#/components/schemas/CallState' },
+                    outcome: { type: 'string' },
+                },
+            },
+            CallEventWithIntegrationEntities: {
+                allOf: [
+                    { $ref: '#/components/schemas/CallEvent' },
+                    {
+                        type: 'object',
+                        required: ['integrationEntities'],
+                        properties: {
+                            integrationEntities: {
+                                type: 'array',
+                                items: { $ref: '#/components/schemas/IntegrationEntity' },
+                            },
+                        },
+                    },
+                ],
+            },
+            Task: {
+                type: 'object',
+                required: ['id', 'content', 'createdAt', 'dueAt', 'title', 'type'],
+                properties: {
+                    id: { type: 'string' },
+                    content: { type: 'string' },
+                    createdAt: { type: 'number' },
+                    dueAt: { type: 'number' },
+                    title: { type: 'string' },
+                    type: { type: 'string' },
+                    link: { type: 'string' },
+                },
+            },
+            FollowUpWithIntegrationEntities: {
+                type: 'object',
+                required: ['content', 'dueAt', 'title', 'type', 'integrationEntities'],
+                properties: {
+                    content: { type: 'string' },
+                    dueAt: { type: 'number' },
+                    title: { type: 'string' },
+                    type: { type: 'string' },
+                    integrationEntities: {
+                        type: 'array',
+                        items: { $ref: '#/components/schemas/IntegrationEntity' },
+                    },
+                },
+            },
+            IntegrationDefinedOptions: {
+                type: 'object',
+                required: ['label'],
+                properties: {
+                    label: { type: 'string' },
+                    type: { type: 'string' },
+                    options: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            required: ['label', 'key'],
+                            properties: {
+                                label: { type: 'string' },
+                                key: { type: 'string' },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    },
+};
+//# sourceMappingURL=openapi-spec.js.map