Skip to main content

Entities references

Action​

/** Supported action types.
 */
enum ActionType {
  Accept = 'accept',
  Reject = 'reject',
  Unselected = 'unselected',
}

/** A consent Action represents a single input from a Subject.
 *
 * In the Cookie Consent flow, it might be opt-in/opt-out actions on a specific cookie.
 *
 */
type Action = {
  /** Privacy Protocol ID associated with this action. */
  target: string
  /** UC Configuration ID associated with this action. */
  vendor: string
  /** Type of action performed on the target object. */
  action: ActionType
  /** Optional jurisdiction of the action. */
  jurisdiction?: string
}

ActionWithConsent​

import { ActionType } from './Action'

/**
 * Represents a consent and its included actions.
 */
type ActionWithConsent = {
  /** Target object of this Action. */
  target: string
  /** Vendor that owns the target object. */
  vendor: string
  /** Type of action performed on the target object. */
  action: ActionType
  /** Consent Id. */
  consentId: string
  /** Channel Id. */
  channelId: string
  /** Creation Date of this consent.*/
  createdAt: Date
}

AuthorizationConfig​

/** This type defines the configuration required by the function [getToken] of [UnifiedConsentByOsanoSDK] to work.
 */
type AuthorizationConfig = {
  /** URL of authorization services provider */
  issuer: string
  /** The  config Id */
  configId: string
  /** The Collection Id */
  collectionId: string
  /** The Client Id */
  customerId: string
}

ClientConfig​

/**
 * This type defines the configuration required by a UnifiedConsentByOsanoClient to work.
 */
type ClientConfig = {
  /** Token with authorization to execute call to the Core API */
  token: string
  /** Osano's Unified Consent API URL */
  apiUrl: string
  /** API Key issued by Osano through the Webapp. Optional, but necessary for calling subject related routes in the Core API */
  osanoApiKey?: string
  /** Set a country code for the client instance */
  overrideCountryCode?: string
  /** Set a region code for the client instance */
  overrideRegionCode?: string
  /** Overrides the default configuration of the cookies*/
  cookieConfig?: {
    /** Amount of days in the future when the cookie expiration will be set */
    expirationInDays?: number
    /** Whether the expiration date should be refreshed on a new visit */
    refreshOnVisit?: boolean
  }
}

EmbeddedConfig​

/** Defines the configuration to initialize the embedded rendering mode.
 */
type EmbeddedConfig = {
  /* A DOM iframe where the target child is rendered */
  targetIframe: HTMLIFrameElement
  cookieConfig?: {
    /** Amount of days in the future when the cookie expiration will be set */
    expirationInDays?: number
    /** Whether the expiration date should be refreshed on a new visit */
    refreshOnVisit?: boolean
  }
}

Collection​

type Collection = {
  id: string
  name: string
  consents: Consent[]
  preferences: Consent[]
}

Conflict​

/** A Conflict represents a collision between Actions within a configuration.
 */
import { ActionWithConsent } from './ActionWithConsent'

type Conflict = {
  /** Type represents the classification why there exists some conflict with the consents */
  type: string
  /** Resolution represents the action taken to resolve the conflict */
  resolution: string
  /** List of actions in conflict */
  actionsInConflict: ActionWithConsent[]
}
type Consent = {
  id: string
  categories: string[]
  enabled: boolean
  title: string
  description: string
  target: string
  defaultAction: string
  acceptWording: string
  rejectWording: string
}

CreateConsentPayload​

type CreateConsentPayload = {
  subject: Subject
  actions: Action[]
  attributes?: any
  tags?: string[]
  compliance?: {
    privacyPolicy?: {
      version?: string
      url: string
    },
    gpc?: 1
  }
  // A country two letter ISO code. Defaults to the resolved country via IP if not provided
  overrideCountryCode?: string
  // A two letter ISO code for the state/division
  overrideRegionCode?: string
}

CreateGpcConsentPayload​

type CreateGpcConsentPayload = {
  subject: Subject
  compliance: {
    gpc: 1
  }
  attributes?: {
    [key: string]: any
  }
  /** An optional jurisdiction override. If not passed, the user's jurisdiction will be determined by IP geolocation. */
  jurisdiction?: string
}

GetUnifiedConsentResponse​

type GetUnifiedConsentResponse = {
  /** Unified Consent contains all the information about consent of a Subject */
  unifiedConsent: UnifiedConsent
  /** List of Conflicts if exists with all the details of resolution */
  conflicts: Conflict[]
}

HasConsentsPayload​

type HasConsentsPayload = {
  /** The subjectId to check for having previous consents */
  subjectId?: string
}

SaveProfilePayload​

type SaveProfilePayload = {
  email: string
  profile?: any
}

VerifySubjectProfilePayload​

type VerifySubjectProfilePayload = {
  email: string
  verificationCode: string
}

PrivacyProtocolsConfig​

/**
 * This type defines the configuration required to register the privacy protocols.
 */
type PrivacyProtocolsConfig = {
  /** Osano's Unified Consent API URL */
  apiUrl: string
  /** Write only api key */
  apiKey: string
  /** Gpc attributes */
  attributes?: Record<string, any>
  /** Cookie-related config */
  cookieConfig?: {
    /** Amount of days in the future when the cookie expiration will be set */
    expirationInDays?: number
    /** Whether the expiration date should be refreshed on a new visit */
    refreshOnVisit?: boolean
  }
}

Subject​

A subject in the system. It can have either an anonymousId or a verifiedId. If it is a verified subject, it can contain a profile

type Subject = {
  verifiedId?: string
  anonymousId?: string
  profile?: {
    email: string
    firstName?: string
    lastName?: string
  }
}

UnifiedConsent​

type UnifiedConsent = {
  /** Subject Id. */
  subjectId: string
  /** Brand Id. */
  brandId: string
  /** List of Actions of consent. */
  actions: Action[]
  /** Attributes of consent. */
  attributes: { [key: string]: any }
}

MessageType​

Supported event types

enum MessageType {
  LOGIN = 'login',
  LOGOUT = 'logout',
  CONSENT_WRITE = 'consent:write',
  CONSENT_WRITE_GPC = 'consent:write:gpc',
  CHILD_INIT = 'child:init',
  CHILD_LOADED = 'child:loaded',
}

MessageListener​

Callback to execute when an event is received

type MessageListener = (message: Message) => void

Message​

type Message = {
  type: MessageType
  data: any
}