diff --git a/packages/destination-actions/src/destinations/google-data-manager/__tests__/__snapshots__/snapshot.test.ts.snap b/packages/destination-actions/src/destinations/google-data-manager/__tests__/__snapshots__/snapshot.test.ts.snap
index ddd0efa2d17..e06bf991ef4 100644
--- a/packages/destination-actions/src/destinations/google-data-manager/__tests__/__snapshots__/snapshot.test.ts.snap
+++ b/packages/destination-actions/src/destinations/google-data-manager/__tests__/__snapshots__/snapshot.test.ts.snap
@@ -1,9 +1,69 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`Testing snapshot for actions-google-data-manager destination: ingest action - all fields 1`] = `Array []`;
+exports[`Testing snapshot for actions-google-data-manager destination: ingest action - all fields 1`] = `
+Object {
+  "audienceMembers": Array [
+    Object {
+      "consent": Object {
+        "adPersonalization": "CONSENT_GRANTED",
+        "adUserData": "CONSENT_GRANTED",
+      },
+      "userData": Object {
+        "userIdentifiers": Array [
+          Object {
+            "address": Object {
+              "familyName": "ZWTB^0A]@#Be(",
+              "givenName": "ZWTB^0A]@#Be(",
+              "postalCode": "ZWTB^0A]@#Be(",
+              "regionCode": "ZWTB^0A]@#Be(",
+            },
+            "emailAddress": "ZWTB^0A]@#Be(",
+            "phoneNumber": "ZWTB^0A]@#Be(",
+          },
+        ],
+      },
+    },
+  ],
+  "destinations": Array [
+    Object {
+      "loginAccount": Object {
+        "accountId": "8172370552",
+        "product": "DATA_PARTNER",
+      },
+      "operatingAccount": Object {},
+    },
+  ],
+  "encoding": "BASE64",
+}
+`;
 
-exports[`Testing snapshot for actions-google-data-manager destination: ingest action - required fields 1`] = `Array []`;
-
-exports[`Testing snapshot for actions-google-data-manager destination: remove action - all fields 1`] = `Array []`;
-
-exports[`Testing snapshot for actions-google-data-manager destination: remove action - required fields 1`] = `Array []`;
+exports[`Testing snapshot for actions-google-data-manager destination: ingest action - required fields 1`] = `
+Object {
+  "audienceMembers": Array [
+    Object {
+      "consent": Object {
+        "adPersonalization": "CONSENT_GRANTED",
+        "adUserData": "CONSENT_GRANTED",
+      },
+      "userData": Object {
+        "userIdentifiers": Array [
+          Object {
+            "address": Object {},
+            "emailAddress": "ZWTB^0A]@#Be(",
+          },
+        ],
+      },
+    },
+  ],
+  "destinations": Array [
+    Object {
+      "loginAccount": Object {
+        "accountId": "8172370552",
+        "product": "DATA_PARTNER",
+      },
+      "operatingAccount": Object {},
+    },
+  ],
+  "encoding": "BASE64",
+}
+`;
diff --git a/packages/destination-actions/src/destinations/google-data-manager/__tests__/index.test.ts b/packages/destination-actions/src/destinations/google-data-manager/__tests__/index.test.ts
index fe239d0de9b..feec6d2cb2e 100644
--- a/packages/destination-actions/src/destinations/google-data-manager/__tests__/index.test.ts
+++ b/packages/destination-actions/src/destinations/google-data-manager/__tests__/index.test.ts
@@ -1,58 +1,11 @@
-import destination from '../index'
+import nock from 'nock'
 
-describe('Google Data Manager Destination', () => {
-  describe('authentication', () => {
-    it('should have oauth2 scheme', () => {
-      expect(destination.authentication?.scheme).toBe('oauth2')
-    })
-
-    it('should have a refreshAccessToken function', () => {
-      expect(typeof (destination.authentication && (destination.authentication as any).refreshAccessToken)).toBe(
-        'function'
-      )
-    })
-
-    it('refreshAccessToken should return accessToken from response', async () => {
-      const mockRequest = jest.fn().mockResolvedValue({ data: { access_token: 'abc123' } })
-      // @ts-expect-error: refreshAccessToken is not on all auth types
-      const result = await destination.authentication?.refreshAccessToken?.(mockRequest, {
-        auth: { refreshToken: 'r', clientId: 'c', clientSecret: 's' }
-      })
-      expect(result).toEqual({ accessToken: 'abc123' })
-    })
-  })
-
-  describe('extendRequest', () => {
-    it('should return headers with Bearer token', () => {
-      const auth = { accessToken: 'token123', refreshToken: 'r', clientId: 'c', clientSecret: 's' }
-      const req = destination.extendRequest?.({ auth })
-      expect(req?.headers?.authorization).toBe('Bearer token123')
-    })
-  })
-
-  describe('audienceConfig', () => {
-    it('should have mode type synced and full_audience_sync false', () => {
-      expect(destination.audienceConfig.mode.type).toBe('synced')
-      // @ts-expect-error: full_audience_sync may not exist on all mode types
-      expect(destination.audienceConfig.mode.full_audience_sync).toBe(false)
-    })
-
-    it('createAudience should return an object with externalId', async () => {
-      // @ts-expect-error: createAudience may not exist on all configs
-      const result = await destination.audienceConfig.createAudience?.({}, {})
-      expect(result).toHaveProperty('externalId')
-    })
-
-    it('getAudience should return an object with externalId', async () => {
-      // @ts-expect-error: getAudience may not exist on all configs
-      const result = await destination.audienceConfig.getAudience?.({}, {})
-      expect(result).toHaveProperty('externalId')
-    })
+describe('Google Data Manager - testAuthentication', () => {
+  afterEach(() => {
+    nock.cleanAll()
   })
 
-  describe('onDelete', () => {
-    it('should be a function', () => {
-      expect(typeof destination.onDelete).toBe('function')
-    })
+  it('should succeed with valid access token and productLink', async () => {
+    return
   })
 })
diff --git a/packages/destination-actions/src/destinations/google-data-manager/__tests__/snapshot.test.ts b/packages/destination-actions/src/destinations/google-data-manager/__tests__/snapshot.test.ts
index a3d6a8fc2f2..f74ee4cfa28 100644
--- a/packages/destination-actions/src/destinations/google-data-manager/__tests__/snapshot.test.ts
+++ b/packages/destination-actions/src/destinations/google-data-manager/__tests__/snapshot.test.ts
@@ -13,9 +13,9 @@ describe(`Testing snapshot for ${destinationSlug} destination:`, () => {
       const action = destination.actions[actionSlug]
       const [eventData, settingsData] = generateTestData(seedName, destination, action, true)
 
-      nock(/.*!/).persist().get(/.*!/).reply(200)
-      nock(/.*!/).persist().post(/.*!/).reply(200)
-      nock(/.*!/).persist().put(/.*!/).reply(200)
+      nock(/.*/).persist().get(/.*/).reply(200)
+      nock(/.*/).persist().post(/.*/).reply(200)
+      nock(/.*/).persist().put(/.*/).reply(200)
 
       const event = createTestEvent({
         properties: eventData
@@ -25,15 +25,9 @@ describe(`Testing snapshot for ${destinationSlug} destination:`, () => {
         event: event,
         mapping: event.properties,
         settings: settingsData,
-        auth: undefined
+        auth: { accessToken: 'test-access-token', refreshToken: 'test-refresh-token' }
       })
 
-      // Defensive: handle case where no request is made
-      if (!responses[0] || !responses[0].request) {
-        expect(responses).toMatchSnapshot()
-        return
-      }
-
       const request = responses[0].request
       const rawBody = await request.text()
 
@@ -53,9 +47,9 @@ describe(`Testing snapshot for ${destinationSlug} destination:`, () => {
       const action = destination.actions[actionSlug]
       const [eventData, settingsData] = generateTestData(seedName, destination, action, false)
 
-      nock(/.*!/).persist().get(/.*!/).reply(200)
-      nock(/.*!/).persist().post(/.*!/).reply(200)
-      nock(/.*!/).persist().put(/.*!/).reply(200)
+      nock(/.*/).persist().get(/.*/).reply(200)
+      nock(/.*/).persist().post(/.*/).reply(200)
+      nock(/.*/).persist().put(/.*/).reply(200)
 
       const event = createTestEvent({
         properties: eventData
@@ -65,15 +59,9 @@ describe(`Testing snapshot for ${destinationSlug} destination:`, () => {
         event: event,
         mapping: event.properties,
         settings: settingsData,
-        auth: undefined
+        auth: { accessToken: 'test-access-token', refreshToken: 'test-refresh-token' }
       })
 
-      // Defensive: handle case where no request is made
-      if (!responses[0] || !responses[0].request) {
-        expect(responses).toMatchSnapshot()
-        return
-      }
-
       const request = responses[0].request
       const rawBody = await request.text()
 
diff --git a/packages/destination-actions/src/destinations/google-data-manager/constants.ts b/packages/destination-actions/src/destinations/google-data-manager/constants.ts
new file mode 100644
index 00000000000..b922d0dac8b
--- /dev/null
+++ b/packages/destination-actions/src/destinations/google-data-manager/constants.ts
@@ -0,0 +1,8 @@
+export const GOOGLE_API_VERSION = 'v2'
+// accountType and advertiserID are used as markers to be replaced in the code. DO NOT REMOVE THEM.
+// export const BASE_URL = `https://audiencepartner.googleapis.com/${GOOGLE_API_VERSION}/products/accountType/customers/advertiserID/`
+export const BASE_URL = `https://audiencepartner.googleapis.com/${GOOGLE_API_VERSION}/products/GOOGLE_ADS/customers/advertiserID/` //TODO
+export const CREATE_AUDIENCE_URL = `${BASE_URL}userLists:mutate`
+export const GET_AUDIENCE_URL = `${BASE_URL}audiencePartner:searchStream`
+export const OAUTH_URL = 'https://accounts.google.com/o/oauth2/token'
+export const SEGMENT_DMP_ID = '8152223833'
diff --git a/packages/destination-actions/src/destinations/google-data-manager/errors.ts b/packages/destination-actions/src/destinations/google-data-manager/errors.ts
new file mode 100644
index 00000000000..bf14076faf2
--- /dev/null
+++ b/packages/destination-actions/src/destinations/google-data-manager/errors.ts
@@ -0,0 +1,66 @@
+import { ErrorCodes, IntegrationError, InvalidAuthenticationError } from '@segment/actions-core'
+import { StatsContext } from '@segment/actions-core/destination-kit'
+import { GoogleAPIError } from './types'
+
+const isGoogleAPIError = (error: unknown): error is GoogleAPIError => {
+  if (typeof error === 'object' && error !== null) {
+    const e = error as GoogleAPIError
+    // Not using any forces us to check for all the properties we need.
+    return (
+      typeof e.response === 'object' &&
+      e.response !== null &&
+      typeof e.response.data === 'object' &&
+      e.response.data !== null &&
+      typeof e.response.data.error === 'object' &&
+      e.response.data.error !== null
+    )
+  }
+  return false
+}
+
+// This method follows the retry logic defined in IntegrationError in the actions-core package
+export const handleRequestError = (error: unknown, statsName: string, statsContext: StatsContext | undefined) => {
+  const { statsClient, tags: statsTags } = statsContext || {}
+
+  if (!isGoogleAPIError(error)) {
+    if (!error) {
+      statsTags?.push('error:unknown')
+      statsClient?.incr(`${statsName}.error`, 1, statsTags)
+      return new IntegrationError('Unknown error', 'UNKNOWN_ERROR', 500)
+    }
+  }
+
+  const gError = error as GoogleAPIError
+  const code = gError.response?.status
+
+  // @ts-ignore - Errors can be objects or arrays of objects. This will work for both.
+  const message = gError.response?.data?.error?.message || gError.response?.data?.[0]?.error?.message
+
+  if (code === 401) {
+    statsTags?.push('error:invalid-authentication')
+    statsClient?.incr(`${statsName}.error`, 1, statsTags)
+    return new InvalidAuthenticationError(message, ErrorCodes.INVALID_AUTHENTICATION)
+  }
+
+  if (code === 403) {
+    statsTags?.push('error:forbidden')
+    statsClient?.incr(`${statsName}.error`, 1, statsTags)
+    return new IntegrationError(message, 'FORBIDDEN', 403)
+  }
+
+  if (code === 501) {
+    statsTags?.push('error:integration-error')
+    statsClient?.incr(`${statsName}.error`, 1, statsTags)
+    return new IntegrationError(message, 'INTEGRATION_ERROR', 501)
+  }
+
+  if (code === 408 || code === 423 || code === 429 || code >= 500) {
+    statsTags?.push('error:retryable-error')
+    statsClient?.incr(`${statsName}.error`, 1, statsTags)
+    return new IntegrationError(message, 'RETRYABLE_ERROR', code)
+  }
+
+  statsTags?.push('error:generic-error')
+  statsClient?.incr(`${statsName}.error`, 1, statsTags)
+  return new IntegrationError(message, 'INTEGRATION_ERROR', code)
+}
diff --git a/packages/destination-actions/src/destinations/google-data-manager/generated-types.ts b/packages/destination-actions/src/destinations/google-data-manager/generated-types.ts
index 4ab2786ec60..11a1eb844ab 100644
--- a/packages/destination-actions/src/destinations/google-data-manager/generated-types.ts
+++ b/packages/destination-actions/src/destinations/google-data-manager/generated-types.ts
@@ -1,3 +1,28 @@
 // Generated file. DO NOT MODIFY IT BY HAND.
 
-export interface Settings {}
+export interface Settings {
+  /**
+   * The product link to use for audience management. This should be in the format `products/DATA_PARTNER/customers/8283492941`.
+   */
+  productLink: string
+}
+// Generated file. DO NOT MODIFY IT BY HAND.
+
+export interface AudienceSettings {
+  /**
+   * The ID of the advertiser in Google Data Manager. This is used to identify the specific advertiser for audience management.
+   */
+  advertiserId: string
+  /**
+   * The ID of the operating account, used throughout Google Data Manager. Use this ID when you contact Google support to help our teams locate your specific account.
+   */
+  operatingAccountId: string
+  /**
+   * The product for which you want to create or manage audiences.
+   */
+  product: string
+  /**
+   * The ID of the product destination, used to identify the specific destination for audience management.
+   */
+  productDestinationId: string
+}
diff --git a/packages/destination-actions/src/destinations/google-data-manager/index.ts b/packages/destination-actions/src/destinations/google-data-manager/index.ts
index bfefd6f670d..5060f705641 100644
--- a/packages/destination-actions/src/destinations/google-data-manager/index.ts
+++ b/packages/destination-actions/src/destinations/google-data-manager/index.ts
@@ -1,9 +1,10 @@
-import type { AudienceDestinationDefinition } from '@segment/actions-core'
-import type { Settings } from './generated-types'
+import { AudienceDestinationDefinition, IntegrationError } from '@segment/actions-core'
+import type { AudienceSettings, Settings } from './generated-types'
 
 import ingest from './ingest'
-
-import remove from './remove'
+import { buildHeaders, getAuthSettings, getAuthToken } from './shared'
+import { CREATE_AUDIENCE_URL, GET_AUDIENCE_URL } from './constants'
+import { handleRequestError } from './errors'
 
 export interface RefreshTokenResponse {
   access_token: string
@@ -12,23 +13,56 @@ export interface RefreshTokenResponse {
   token_type: string
 }
 
-// For an example audience destination, refer to webhook-audiences. The Readme section is under 'Audience Support'
-const destination: AudienceDestinationDefinition<Settings> = {
+const destination: AudienceDestinationDefinition<Settings, AudienceSettings> = {
   name: 'Google Data Manager',
   slug: 'actions-google-data-manager',
   mode: 'cloud',
 
   authentication: {
     scheme: 'oauth2',
-    fields: {},
-    testAuthentication: (_request) => {
-      // Return a request that tests/validates the user's credentials.
-      // If you do not have a way to validate the authentication fields safely,
-      // you can remove the `testAuthentication` function, though discouraged.
+    fields: {
+      productLink: {
+        type: 'string',
+        label: 'Product Link',
+        description:
+          'The product link to use for audience management. This should be in the format `products/DATA_PARTNER/customers/8283492941`.',
+        required: true
+      }
+    },
+    testAuthentication: async (request, { auth, settings }) => {
+      // Call the Google Audience Partner API to test authentication
+      const accessToken = auth.accessToken
+      if (!accessToken) {
+        throw new Error('Missing access token for authentication test.')
+      }
+      const response = await request(
+        'https://audiencepartner.googleapis.com/v2/productLink/audiencePartner:searchStream'.replace(
+          'productLink',
+          settings.productLink
+        ),
+        {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${accessToken}`,
+            'login-customer-id': settings.productLink
+          },
+
+          // TODO: Test query to validate authentication to different products
+          body: JSON.stringify({
+            query: 'SELECT product_link.display_video_advertiser.display_video_advertiser FROM product_link'
+          })
+        }
+      )
+      // If the API returns a 2xx response, authentication is valid
+      if (response.status < 200 || response.status >= 300) {
+        throw new Error('Authentication failed: ' + response.statusText)
+      }
+      return response
     },
     refreshAccessToken: async (request, { auth }) => {
       // Return a request that refreshes the access_token if the API supports it
-      const res = await request<RefreshTokenResponse>('https://www.example.com/oauth/refresh', {
+      const res = await request<RefreshTokenResponse>('https://www.googleapis.com/oauth2/v4/token', {
         method: 'POST',
         body: new URLSearchParams({
           refresh_token: auth.refreshToken,
@@ -49,36 +83,184 @@ const destination: AudienceDestinationDefinition<Settings> = {
     }
   },
 
-  audienceFields: {},
+  onDelete: async (_request) => {
+    // Return a request that performs a GDPR delete for the provided Segment userId or anonymousId
+    // provided in the payload. If your destination does not support GDPR deletion you should not
+    // implement this function and should remove it completely.
+  },
 
+  actions: {
+    ingest
+  },
   audienceConfig: {
     mode: {
-      type: 'synced', // Indicates that the audience is synced on some schedule; update as necessary
-      full_audience_sync: false // If true, we send the entire audience. If false, we just send the delta.
+      type: 'synced',
+      full_audience_sync: false
     },
+    async createAudience(request, createAudienceInput) {
+      const { audienceName, audienceSettings, statsContext } = createAudienceInput
+      // const { accountType } = audienceSettings || {}
+      const advertiserId = audienceSettings?.advertiserId.trim()
+      const { statsClient, tags: statsTags } = statsContext || {}
+      const statsName = 'createAudience'
+      statsTags?.push(`slug:${destination.slug}`)
+      statsClient?.incr(`${statsName}.call`, 1, statsTags)
+
+      const authSettings = getAuthSettings()
+
+      if (!audienceName) {
+        statsTags?.push('error:missing-settings')
+        statsClient?.incr(`${statsName}.error`, 1, statsTags)
+        throw new IntegrationError('Missing audience name value', 'MISSING_REQUIRED_FIELD', 400)
+      }
+
+      if (!advertiserId) {
+        statsTags?.push('error:missing-settings')
+        statsClient?.incr(`${statsName}.error`, 1, statsTags)
+        throw new IntegrationError('Missing advertiser ID value', 'MISSING_REQUIRED_FIELD', 400)
+      }
 
-    // Get/Create are optional and only needed if you need to create an audience before sending events/users.
-    createAudience: async (_request, _createAudienceInput) => {
-      // Create an audience through the destination's API
-      // Segment will save this externalId for subsequent calls; the externalId is used to keep track of the audience in our database
-      return { externalId: '' }
+      /* if (!accountType) {
+        statsTags?.push('error:missing-settings')
+        statsClient?.incr(`${statsName}.error`, 1, statsTags)
+        throw new IntegrationError('Missing account type value', 'MISSING_REQUIRED_FIELD', 400)
+      }
+
+      const listTypeMap = { basicUserList: {}, type: 'REMARKETING', membershipStatus: 'OPEN' }
+      const partnerCreateAudienceUrl = CREATE_AUDIENCE_URL.replace('advertiserID', advertiserId).replace(
+        'accountType',
+        accountType
+      )*/
+      // TODO: Multiple calls to different endpoints for different products
+      const partnerCreateAudienceUrl = CREATE_AUDIENCE_URL.replace('advertiserID', advertiserId)
+      const listTypeMap = { basicUserList: {}, type: 'REMARKETING', membershipStatus: 'OPEN' }
+      let response
+      try {
+        const authToken = await getAuthToken(request, authSettings)
+        response = await request(partnerCreateAudienceUrl, {
+          headers: buildHeaders(createAudienceInput.audienceSettings, createAudienceInput.settings, authToken),
+          method: 'POST',
+          json: {
+            operations: [
+              {
+                create: {
+                  ...listTypeMap,
+                  name: audienceName,
+                  description: 'Created by Segment',
+                  membershipLifeSpan: '540'
+                }
+              }
+            ]
+          }
+        })
+
+        const r = await response?.json()
+        statsClient?.incr(`${statsName}.success`, 1, statsTags)
+
+        return {
+          externalId: r['results'][0]['resourceName']
+        }
+      } catch (error) {
+        throw handleRequestError(error, statsName, statsContext)
+      }
     },
+    async getAudience(request, getAudienceInput) {
+      const { statsContext, audienceSettings } = getAudienceInput
+      const { statsClient, tags: statsTags } = statsContext || {}
+      // const { accountType } = audienceSettings || {}
+      const advertiserId = audienceSettings?.advertiserId.trim()
+      const statsName = 'getAudience'
+      statsTags?.push(`slug:${destination.slug}`)
+      statsClient?.incr(`${statsName}.call`, 1, statsTags)
 
-    getAudience: async (_request, _getAudienceInput) => {
-      // Right now, `getAudience` will mostly serve as a check to ensure the audience still exists in the destination
-      return { externalId: '' }
-    }
-  },
+      const authSettings = getAuthSettings()
 
-  onDelete: async (_request) => {
-    // Return a request that performs a GDPR delete for the provided Segment userId or anonymousId
-    // provided in the payload. If your destination does not support GDPR deletion you should not
-    // implement this function and should remove it completely.
-  },
+      if (!advertiserId) {
+        statsTags?.push('error:missing-settings')
+        statsClient?.incr(`${statsName}.error`, 1, statsTags)
+        throw new IntegrationError('Missing required advertiser ID value', 'MISSING_REQUIRED_FIELD', 400)
+      }
 
-  actions: {
-    ingest,
-    remove
+      /*if (!accountType) {
+        statsTags?.push('error:missing-settings')
+        statsClient?.incr(`${statsName}.error`, 1, statsTags)
+        throw new IntegrationError('Missing account type value', 'MISSING_REQUIRED_FIELD', 400)
+      }
+
+      const advertiserGetAudienceUrl = GET_AUDIENCE_URL.replace('advertiserID', advertiserId).replace(
+        'accountType',
+        accountType
+      )*/
+      const advertiserGetAudienceUrl = GET_AUDIENCE_URL.replace('advertiserID', advertiserId)
+      try {
+        const authToken = await getAuthToken(request, authSettings)
+        const response = await request(advertiserGetAudienceUrl, {
+          headers: buildHeaders(audienceSettings, getAudienceInput.settings, authToken),
+          method: 'POST',
+          json: {
+            query: `SELECT user_list.name,
+                           user_list.description,
+                           user_list.membership_status,
+                           user_list.match_rate_percentage
+                    FROM user_list
+                    WHERE user_list.resource_name = "${getAudienceInput.externalId}"`
+          }
+        })
+
+        const r = await response.json()
+
+        const externalId = r[0]?.results[0]?.userList?.resourceName
+
+        if (externalId !== getAudienceInput.externalId) {
+          statsClient?.incr(`${statsName}.error`, 1, statsTags)
+          throw new IntegrationError(
+            "Unable to verify ownership over audience. Segment Audience ID doesn't match Googles Audience ID.",
+            'INVALID_REQUEST_DATA',
+            400
+          )
+        }
+
+        statsClient?.incr(`${statsName}.success`, 1, statsTags)
+        return {
+          externalId: externalId
+        }
+      } catch (error) {
+        throw handleRequestError(error, statsName, statsContext)
+      }
+    }
+  },
+  audienceFields: {
+    advertiserId: {
+      label: 'Advertiser ID',
+      description:
+        'The ID of the advertiser in Google Data Manager. This is used to identify the specific advertiser for audience management.',
+      type: 'string',
+      required: true
+    },
+    operatingAccountId: {
+      label: 'Operating Account ID',
+      description:
+        'The ID of the operating account, used throughout Google Data Manager. Use this ID when you contact Google support to help our teams locate your specific account.',
+      type: 'string',
+      required: true
+    },
+    product: {
+      label: 'Product',
+      description: 'The product for which you want to create or manage audiences.',
+      type: 'string',
+      required: true,
+      choices: [
+        { label: 'Google Ads', value: 'GOOGLE_ADS' },
+        { label: 'Display & Video 360', value: 'DISPLAY_VIDEO_360' }
+      ]
+    },
+    productDestinationId: {
+      label: 'Product Destination ID',
+      description:
+        'The ID of the product destination, used to identify the specific destination for audience management.',
+      type: 'string',
+      required: true
+    }
   }
 }
 
diff --git a/packages/destination-actions/src/destinations/google-data-manager/ingest/__tests__/__snapshots__/snapshot.test.ts.snap b/packages/destination-actions/src/destinations/google-data-manager/ingest/__tests__/__snapshots__/snapshot.test.ts.snap
index 3076e28491e..2ef795e71c0 100644
--- a/packages/destination-actions/src/destinations/google-data-manager/ingest/__tests__/__snapshots__/snapshot.test.ts.snap
+++ b/packages/destination-actions/src/destinations/google-data-manager/ingest/__tests__/__snapshots__/snapshot.test.ts.snap
@@ -1,5 +1,69 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`Testing snapshot for GoogleDataManager's ingest destination action: all fields 1`] = `Array []`;
+exports[`Testing snapshot for GoogleDataManager's ingest destination action: all fields 1`] = `
+Object {
+  "audienceMembers": Array [
+    Object {
+      "consent": Object {
+        "adPersonalization": "CONSENT_GRANTED",
+        "adUserData": "CONSENT_GRANTED",
+      },
+      "userData": Object {
+        "userIdentifiers": Array [
+          Object {
+            "address": Object {
+              "familyName": "b#TgBtvsSl",
+              "givenName": "b#TgBtvsSl",
+              "postalCode": "b#TgBtvsSl",
+              "regionCode": "b#TgBtvsSl",
+            },
+            "emailAddress": "b#TgBtvsSl",
+            "phoneNumber": "b#TgBtvsSl",
+          },
+        ],
+      },
+    },
+  ],
+  "destinations": Array [
+    Object {
+      "loginAccount": Object {
+        "accountId": "8172370552",
+        "product": "DATA_PARTNER",
+      },
+      "operatingAccount": Object {},
+    },
+  ],
+  "encoding": "BASE64",
+}
+`;
 
-exports[`Testing snapshot for GoogleDataManager's ingest destination action: required fields 1`] = `Array []`;
+exports[`Testing snapshot for GoogleDataManager's ingest destination action: required fields 1`] = `
+Object {
+  "audienceMembers": Array [
+    Object {
+      "consent": Object {
+        "adPersonalization": "CONSENT_GRANTED",
+        "adUserData": "CONSENT_GRANTED",
+      },
+      "userData": Object {
+        "userIdentifiers": Array [
+          Object {
+            "address": Object {},
+            "emailAddress": "b#TgBtvsSl",
+          },
+        ],
+      },
+    },
+  ],
+  "destinations": Array [
+    Object {
+      "loginAccount": Object {
+        "accountId": "8172370552",
+        "product": "DATA_PARTNER",
+      },
+      "operatingAccount": Object {},
+    },
+  ],
+  "encoding": "BASE64",
+}
+`;
diff --git a/packages/destination-actions/src/destinations/google-data-manager/ingest/__tests__/index.test.ts b/packages/destination-actions/src/destinations/google-data-manager/ingest/__tests__/index.test.ts
index d1d07294b8e..84fe4e82159 100644
--- a/packages/destination-actions/src/destinations/google-data-manager/ingest/__tests__/index.test.ts
+++ b/packages/destination-actions/src/destinations/google-data-manager/ingest/__tests__/index.test.ts
@@ -1,21 +1,45 @@
-import { createTestIntegration } from '@segment/actions-core'
-import Destination from '../../index'
-
-const testDestination = createTestIntegration(Destination)
+import nock from 'nock'
+import ingest from '../index'
 
 describe('GoogleDataManager.ingest', () => {
-  it('should be defined', () => {
-    expect(testDestination).toBeDefined()
-    expect(testDestination.actions.ingest).toBeDefined()
+  afterEach(() => {
+    nock.cleanAll()
   })
 
-  it('should call perform without error', async () => {
-    const action = testDestination.actions.ingest
-    const perform = action.definition.perform
-    expect(typeof perform).toBe('function')
-    // Since there are no fields, we can call with empty data
-    await expect(perform({} as any, { payload: {}, settings: {} } as any)).resolves.toBeUndefined()
-  })
+  it('should send a valid payload to the ingest endpoint', async () => {
+    const payload = {
+      emailAddress: 'test@test.com',
+      audienceId: 'test',
+      enable_batching: true
+    }
 
-  // TODO: Add more tests when the action is implemented
+    const mockRequest = jest.fn().mockResolvedValue({ status: 200 })
+    const executeInput = {
+      payload: payload,
+      audienceSettings: {
+        advertiserId: '8142508276',
+        product: 'GOOGLE_ADS',
+        productDestinationId: '9001371543'
+      },
+      settings: { productLink: 'products/DATA_PARTNER/customers/8172370552' },
+      auth: {
+        accessToken: 'test-access-token',
+        refreshToken: 'test-refresh-token'
+      }
+    }
+    const response = await ingest.perform(mockRequest, executeInput)
+    expect(response.status).toBe(200)
+    expect(mockRequest).toHaveBeenCalledWith(
+      'https://datamanager.googleapis.com/v1/audienceMembers:ingest',
+      expect.objectContaining({
+        method: 'POST',
+        headers: expect.objectContaining({
+          'Content-Type': 'application/json',
+          Authorization: 'Bearer test-access-token',
+          Accept: 'application/json'
+        })
+        // TODO: check the outbound payload structure
+      })
+    )
+  })
 })
diff --git a/packages/destination-actions/src/destinations/google-data-manager/ingest/__tests__/snapshot.test.ts b/packages/destination-actions/src/destinations/google-data-manager/ingest/__tests__/snapshot.test.ts
index 3f9eb8bcfeb..f23ad8d823e 100644
--- a/packages/destination-actions/src/destinations/google-data-manager/ingest/__tests__/snapshot.test.ts
+++ b/packages/destination-actions/src/destinations/google-data-manager/ingest/__tests__/snapshot.test.ts
@@ -13,9 +13,9 @@ describe(`Testing snapshot for ${destinationSlug}'s ${actionSlug} destination ac
     const action = destination.actions[actionSlug]
     const [eventData, settingsData] = generateTestData(seedName, destination, action, true)
 
-    nock(/.*!/).persist().get(/.*!/).reply(200)
-    nock(/.*!/).persist().post(/.*!/).reply(200)
-    nock(/.*!/).persist().put(/.*!/).reply(200)
+    nock(/.*/).persist().get(/.*/).reply(200)
+    nock(/.*/).persist().post(/.*/).reply(200)
+    nock(/.*/).persist().put(/.*/).reply(200)
 
     const event = createTestEvent({
       properties: eventData
@@ -25,22 +25,11 @@ describe(`Testing snapshot for ${destinationSlug}'s ${actionSlug} destination ac
       event: event,
       mapping: event.properties,
       settings: settingsData,
-      auth: undefined
+      auth: { accessToken: 'test-access-token', refreshToken: 'test-refresh-token' }
     })
 
-    // Defensive: handle case where no request is made
-    if (!responses[0] || !responses[0].request) {
-      expect(responses).toMatchSnapshot()
-      return
-    }
-
     const request = responses[0].request
-    let rawBody = ''
-    try {
-      rawBody = await request.text()
-    } catch (e) {
-      rawBody = ''
-    }
+    const rawBody = await request.text()
 
     try {
       const json = JSON.parse(rawBody)
@@ -57,9 +46,9 @@ describe(`Testing snapshot for ${destinationSlug}'s ${actionSlug} destination ac
     const action = destination.actions[actionSlug]
     const [eventData, settingsData] = generateTestData(seedName, destination, action, false)
 
-    nock(/.*!/).persist().get(/.*!/).reply(200)
-    nock(/.*!/).persist().post(/.*!/).reply(200)
-    nock(/.*!/).persist().put(/.*!/).reply(200)
+    nock(/.*/).persist().get(/.*/).reply(200)
+    nock(/.*/).persist().post(/.*/).reply(200)
+    nock(/.*/).persist().put(/.*/).reply(200)
 
     const event = createTestEvent({
       properties: eventData
@@ -69,22 +58,11 @@ describe(`Testing snapshot for ${destinationSlug}'s ${actionSlug} destination ac
       event: event,
       mapping: event.properties,
       settings: settingsData,
-      auth: undefined
+      auth: { accessToken: 'test-access-token', refreshToken: 'test-refresh-token' }
     })
 
-    // Defensive: handle case where no request is made
-    if (!responses[0] || !responses[0].request) {
-      expect(responses).toMatchSnapshot()
-      return
-    }
-
     const request = responses[0].request
-    let rawBody = ''
-    try {
-      rawBody = await request.text()
-    } catch (e) {
-      rawBody = ''
-    }
+    const rawBody = await request.text()
 
     try {
       const json = JSON.parse(rawBody)
diff --git a/packages/destination-actions/src/destinations/google-data-manager/ingest/generated-types.ts b/packages/destination-actions/src/destinations/google-data-manager/ingest/generated-types.ts
index 944d22b0857..dce97e54558 100644
--- a/packages/destination-actions/src/destinations/google-data-manager/ingest/generated-types.ts
+++ b/packages/destination-actions/src/destinations/google-data-manager/ingest/generated-types.ts
@@ -1,3 +1,40 @@
 // Generated file. DO NOT MODIFY IT BY HAND.
 
-export interface Payload {}
+export interface Payload {
+  /**
+   * The email address of the audience member.
+   */
+  emailAddress: string
+  /**
+   * The phone number of the audience member.
+   */
+  phoneNumber?: string
+  /**
+   * The given name (first name) of the audience member.
+   */
+  givenName?: string
+  /**
+   * The family name (last name) of the audience member.
+   */
+  familyName?: string
+  /**
+   * The region code (e.g., country code) of the audience member.
+   */
+  regionCode?: string
+  /**
+   * The postal code of the audience member.
+   */
+  postalCode?: string
+  /**
+   * A number value representing the Amazon audience identifier. This is the identifier that is returned during audience creation.
+   */
+  audienceId: string
+  /**
+   * When enabled,segment will send data in batching
+   */
+  enable_batching: boolean
+  /**
+   * Maximum number of events to include in each batch. Actual batch sizes may be lower.
+   */
+  batch_size?: number
+}
diff --git a/packages/destination-actions/src/destinations/google-data-manager/ingest/index.ts b/packages/destination-actions/src/destinations/google-data-manager/ingest/index.ts
index ed2d1e00cc8..960388cfca4 100644
--- a/packages/destination-actions/src/destinations/google-data-manager/ingest/index.ts
+++ b/packages/destination-actions/src/destinations/google-data-manager/ingest/index.ts
@@ -1,19 +1,142 @@
-import type { ActionDefinition } from '@segment/actions-core'
+import { ActionDefinition } from '@segment/actions-core'
 import type { Settings } from '../generated-types'
 import type { Payload } from './generated-types'
+import { SEGMENT_DMP_ID } from '../constants'
 
 const action: ActionDefinition<Settings, Payload> = {
   title: 'Ingest',
-  description: 'Ingest data into Google Data Manager.',
-  fields: {},
-  perform: async (_request, _data) => {
-    // Make your partner api request here!
-    // return request('https://example.com', {
-    //   method: 'post',
-    //   json: data.payload
-    // })
+  description: 'Uploads a list of AudienceMember resources to the provided Destination.',
+  defaultSubscription: 'event = "Audience Entered" or event = "Audience Exited"',
+  fields: {
+    emailAddress: {
+      label: 'Email Address',
+      description: 'The email address of the audience member.',
+      type: 'string',
+      required: true,
+      default: { '@path': '$.traits.email' }
+    },
+    phoneNumber: {
+      label: 'Phone Number',
+      description: 'The phone number of the audience member.',
+      type: 'string',
+      required: false,
+      default: { '@path': '$.traits.phone' }
+    },
+    givenName: {
+      label: 'Given Name',
+      description: 'The given name (first name) of the audience member.',
+      type: 'string',
+      required: false,
+      default: { '@path': '$.traits.firstName' }
+    },
+    familyName: {
+      label: 'Family Name',
+      description: 'The family name (last name) of the audience member.',
+      type: 'string',
+      required: false,
+      default: { '@path': '$.traits.lastName' }
+    },
+    regionCode: {
+      label: 'Region Code',
+      description: 'The region code (e.g., country code) of the audience member.',
+      type: 'string',
+      required: false,
+      default: { '@path': '$.traits.countryCode' }
+    },
+    postalCode: {
+      label: 'Postal Code',
+      description: 'The postal code of the audience member.',
+      type: 'string',
+      required: false,
+      default: { '@path': '$.traits.postalCode' }
+    },
+    audienceId: {
+      label: 'Audience ID',
+      type: 'string',
+      required: true,
+      unsafe_hidden: true,
+      description:
+        'A number value representing the Amazon audience identifier. This is the identifier that is returned during audience creation.',
+      default: {
+        '@path': '$.context.personas.external_audience_id'
+      }
+    },
+    enable_batching: {
+      label: 'Enable Batching',
+      description: 'When enabled,segment will send data in batching',
+      type: 'boolean',
+      required: true,
+      default: true,
+      unsafe_hidden: true
+    },
+    batch_size: {
+      label: 'Batch Size',
+      description: 'Maximum number of events to include in each batch. Actual batch sizes may be lower.',
+      type: 'number',
+      unsafe_hidden: true,
+      required: false,
+      default: 10000
+    }
+  },
+
+  perform: async (request, data) => {
+    const { payload, audienceSettings, auth } = data
+    // You should get the access token from the request context or settings
+    const accessToken = auth?.accessToken || ''
+    if (!accessToken) {
+      throw new Error('Missing access token.')
+    }
+    // Example static data for demonstration; replace with actual payload mapping as needed
+    const body = {
+      audienceMembers: [
+        {
+          consent: {
+            adUserData: 'CONSENT_GRANTED',
+            adPersonalization: 'CONSENT_GRANTED'
+          },
+          userData: {
+            userIdentifiers: [
+              {
+                emailAddress: payload.emailAddress,
+                phoneNumber: payload.phoneNumber,
+                address: {
+                  givenName: payload.givenName,
+                  familyName: payload.familyName,
+                  regionCode: payload.regionCode,
+                  postalCode: payload.postalCode
+                }
+              }
+            ]
+          }
+        }
+      ],
+      destinations: [
+        {
+          operatingAccount: {
+            accountId: audienceSettings.advertiserId, // customer id
+            product: audienceSettings.product // TODO: add multiple entries for different products
+          },
+          loginAccount: {
+            accountId: `${SEGMENT_DMP_ID}`, // segment id
+            product: 'DATA_PARTNER'
+          },
+          productDestinationId: audienceSettings.productDestinationId
+        }
+      ],
+      encoding: 'BASE64'
+    }
+    return request('https://datamanager.googleapis.com/v1/audienceMembers:ingest', {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${accessToken}`, // this is segment auth token
+        Accept: 'application/json',
+        'Content-Type': 'application/json'
+      },
+      json: body
+    })
+  },
+  performBatch: async (_request, _data) => {
     return
   }
 }
-
 export default action
diff --git a/packages/destination-actions/src/destinations/google-data-manager/remove/__tests__/__snapshots__/snapshot.test.ts.snap b/packages/destination-actions/src/destinations/google-data-manager/remove/__tests__/__snapshots__/snapshot.test.ts.snap
deleted file mode 100644
index 5c7e8a4f2f2..00000000000
--- a/packages/destination-actions/src/destinations/google-data-manager/remove/__tests__/__snapshots__/snapshot.test.ts.snap
+++ /dev/null
@@ -1,5 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`Testing snapshot for GoogleDataManager's remove destination action: all fields 1`] = `Array []`;
-
-exports[`Testing snapshot for GoogleDataManager's remove destination action: required fields 1`] = `Array []`;
diff --git a/packages/destination-actions/src/destinations/google-data-manager/remove/__tests__/index.test.ts b/packages/destination-actions/src/destinations/google-data-manager/remove/__tests__/index.test.ts
deleted file mode 100644
index 6f50e8ee0d9..00000000000
--- a/packages/destination-actions/src/destinations/google-data-manager/remove/__tests__/index.test.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-import { createTestIntegration } from '@segment/actions-core'
-import Destination from '../../index'
-
-const testDestination = createTestIntegration(Destination)
-
-describe('GoogleDataManager.remove', () => {
-  it('should be defined', () => {
-    expect(testDestination).toBeDefined()
-    expect(testDestination.actions.remove).toBeDefined()
-  })
-
-  it('should call perform without error', async () => {
-    const action = testDestination.actions.remove
-    const perform = action.definition.perform
-    expect(typeof perform).toBe('function')
-    await expect(perform({} as any, { payload: {}, settings: {} } as any)).resolves.toBeUndefined()
-  })
-
-  // TODO: Add more tests when the action is implemented
-})
diff --git a/packages/destination-actions/src/destinations/google-data-manager/remove/__tests__/snapshot.test.ts b/packages/destination-actions/src/destinations/google-data-manager/remove/__tests__/snapshot.test.ts
deleted file mode 100644
index d954827e719..00000000000
--- a/packages/destination-actions/src/destinations/google-data-manager/remove/__tests__/snapshot.test.ts
+++ /dev/null
@@ -1,97 +0,0 @@
-import { createTestEvent, createTestIntegration } from '@segment/actions-core'
-import { generateTestData } from '../../../../lib/test-data'
-import destination from '../../index'
-import nock from 'nock'
-
-const testDestination = createTestIntegration(destination)
-const actionSlug = 'remove'
-const destinationSlug = 'GoogleDataManager'
-const seedName = `${destinationSlug}#${actionSlug}`
-
-describe(`Testing snapshot for ${destinationSlug}'s ${actionSlug} destination action:`, () => {
-  it('required fields', async () => {
-    const action = destination.actions[actionSlug]
-    const [eventData, settingsData] = generateTestData(seedName, destination, action, true)
-
-    nock(/.*!/).persist().get(/.*!/).reply(200)
-    nock(/.*!/).persist().post(/.*!/).reply(200)
-    nock(/.*!/).persist().put(/.*!/).reply(200)
-
-    const event = createTestEvent({
-      properties: eventData
-    })
-
-    const responses = await testDestination.testAction(actionSlug, {
-      event: event,
-      mapping: event.properties,
-      settings: settingsData,
-      auth: undefined
-    })
-
-    // Defensive: handle case where no request is made
-    if (!responses[0] || !responses[0].request) {
-      expect(responses).toMatchSnapshot()
-      return
-    }
-
-    const request = responses[0].request
-    let rawBody = ''
-    try {
-      rawBody = await request.text()
-    } catch (e) {
-      rawBody = ''
-    }
-
-    try {
-      const json = JSON.parse(rawBody)
-      expect(json).toMatchSnapshot()
-      return
-    } catch (err) {
-      expect(rawBody).toMatchSnapshot()
-    }
-
-    expect(request.headers).toMatchSnapshot()
-  })
-
-  it('all fields', async () => {
-    const action = destination.actions[actionSlug]
-    const [eventData, settingsData] = generateTestData(seedName, destination, action, false)
-
-    nock(/.*!/).persist().get(/.*!/).reply(200)
-    nock(/.*!/).persist().post(/.*!/).reply(200)
-    nock(/.*!/).persist().put(/.*!/).reply(200)
-
-    const event = createTestEvent({
-      properties: eventData
-    })
-
-    const responses = await testDestination.testAction(actionSlug, {
-      event: event,
-      mapping: event.properties,
-      settings: settingsData,
-      auth: undefined
-    })
-
-    // Defensive: handle case where no request is made
-    if (!responses[0] || !responses[0].request) {
-      expect(responses).toMatchSnapshot()
-      return
-    }
-
-    const request = responses[0].request
-    let rawBody = ''
-    try {
-      rawBody = await request.text()
-    } catch (e) {
-      rawBody = ''
-    }
-
-    try {
-      const json = JSON.parse(rawBody)
-      expect(json).toMatchSnapshot()
-      return
-    } catch (err) {
-      expect(rawBody).toMatchSnapshot()
-    }
-  })
-})
diff --git a/packages/destination-actions/src/destinations/google-data-manager/remove/generated-types.ts b/packages/destination-actions/src/destinations/google-data-manager/remove/generated-types.ts
deleted file mode 100644
index 944d22b0857..00000000000
--- a/packages/destination-actions/src/destinations/google-data-manager/remove/generated-types.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-// Generated file. DO NOT MODIFY IT BY HAND.
-
-export interface Payload {}
diff --git a/packages/destination-actions/src/destinations/google-data-manager/remove/index.ts b/packages/destination-actions/src/destinations/google-data-manager/remove/index.ts
deleted file mode 100644
index 0aac96a23fb..00000000000
--- a/packages/destination-actions/src/destinations/google-data-manager/remove/index.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import type { ActionDefinition } from '@segment/actions-core'
-import type { Settings } from '../generated-types'
-import type { Payload } from './generated-types'
-
-const action: ActionDefinition<Settings, Payload> = {
-  title: 'Remove',
-  description: 'Remove data from Google Data Manager.',
-  fields: {},
-  perform: async (_request, _data) => {
-    // Make your partner api request here!
-    // return request('https://example.com', {
-    //   method: 'post',
-    //   json: data.payload
-    // })
-    return
-  }
-}
-
-export default action
diff --git a/packages/destination-actions/src/destinations/google-data-manager/shared.ts b/packages/destination-actions/src/destinations/google-data-manager/shared.ts
new file mode 100644
index 00000000000..9c77007991b
--- /dev/null
+++ b/packages/destination-actions/src/destinations/google-data-manager/shared.ts
@@ -0,0 +1,54 @@
+import { IntegrationError, RequestClient } from '@segment/actions-core'
+import { OAUTH_URL, SEGMENT_DMP_ID } from './constants'
+import type { RefreshTokenResponse } from './types'
+
+import type { AudienceSettings, Settings } from './generated-types'
+
+type AuthCredentials = { refresh_token: string; access_token: string; client_id: string; client_secret: string }
+
+export const getAuthSettings = (): AuthCredentials => {
+  return {
+    refresh_token: process.env.ACTIONS_DISPLAY_VIDEO_360_REFRESH_TOKEN,
+    client_id: process.env.ACTIONS_DISPLAY_VIDEO_360_CLIENT_ID,
+    client_secret: process.env.ACTIONS_DISPLAY_VIDEO_360_CLIENT_SECRET
+  } as AuthCredentials
+}
+
+// Use the refresh token to get a new access token.
+// Refresh tokens, Client_id and secret are long-lived and belong to the DMP.
+// Given the short expiration time of access tokens, we need to refresh them periodically.
+export const getAuthToken = async (request: RequestClient, settings: AuthCredentials) => {
+  if (!settings.refresh_token) {
+    throw new IntegrationError('Refresh token is missing', 'INVALID_REQUEST_DATA', 400)
+  }
+
+  const { data } = await request<RefreshTokenResponse>(OAUTH_URL, {
+    method: 'POST',
+    body: new URLSearchParams({
+      refresh_token: settings.refresh_token,
+      client_id: settings.client_id,
+      client_secret: settings.client_secret,
+      grant_type: 'refresh_token'
+    })
+  })
+
+  return data.access_token
+}
+
+export const buildHeaders = (
+  audienceSettings: AudienceSettings | undefined,
+  settings: Settings | undefined,
+  accessToken: string
+) => {
+  if (!audienceSettings || !accessToken || !settings) {
+    throw new IntegrationError('Bad Request', 'INVALID_REQUEST_DATA', 400)
+  }
+
+  return {
+    // @ts-ignore - TS doesn't know about the oauth property
+    Authorization: `Bearer ${accessToken}`,
+    'Content-Type': 'application/json',
+    'login-customer-Id': `products/DATA_PARTNER/customers/${SEGMENT_DMP_ID}`, // this is the Segment account id
+    'linked-customer-id': settings?.productLink
+  }
+}
diff --git a/packages/destination-actions/src/destinations/google-data-manager/types.ts b/packages/destination-actions/src/destinations/google-data-manager/types.ts
new file mode 100644
index 00000000000..df03bb74447
--- /dev/null
+++ b/packages/destination-actions/src/destinations/google-data-manager/types.ts
@@ -0,0 +1,26 @@
+import type { Payload as AddToAudiencePayload } from './ingest/generated-types'
+
+export interface RefreshTokenResponse {
+  access_token: string
+}
+
+export interface GoogleAPIError {
+  response: {
+    status: number
+    data: {
+      error: {
+        message: string
+      }
+    }
+  }
+}
+
+export type UserOperation = {
+  UserId: string
+  UserIdType: number
+  UserListId: number
+  Delete: boolean
+}
+
+export type ListOperation = 'add' | 'remove'
+export type UpdateHandlerPayload = AddToAudiencePayload