intrinsic-sdk 0.0.3

data/lib/intrinsic/types/error_schema_error.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative "error_schema_error_type"
+require_relative "error_schema_error_code"
+require "json"
+
+module Intrinsic
+  class ErrorSchemaError
+    attr_reader :type, :message, :code, :param, :additional_properties
+
+    # @param type [ERROR_SCHEMA_ERROR_TYPE]
+    # @param message [String]
+    # @param code [ERROR_SCHEMA_ERROR_CODE]
+    # @param param [String]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [ErrorSchemaError]
+    def initialize(type:, message:, code:, param: nil, additional_properties: nil)
+      # @type [ERROR_SCHEMA_ERROR_TYPE]
+      @type = type
+      # @type [String]
+      @message = message
+      # @type [ERROR_SCHEMA_ERROR_CODE]
+      @code = code
+      # @type [String]
+      @param = param
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of ErrorSchemaError
+    #
+    # @param json_object [JSON]
+    # @return [ErrorSchemaError]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      type = ERROR_SCHEMA_ERROR_TYPE.key(parsed_json["type"]) || parsed_json["type"]
+      message = struct.message
+      code = ERROR_SCHEMA_ERROR_CODE.key(parsed_json["code"]) || parsed_json["code"]
+      param = struct.param
+      new(type: type, message: message, code: code, param: param, additional_properties: struct)
+    end
+
+    # Serialize an instance of ErrorSchemaError to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      {
+        "type": ERROR_SCHEMA_ERROR_TYPE[@type] || @type,
+        "message": @message,
+        "code": ERROR_SCHEMA_ERROR_CODE[@code] || @code,
+        "param": @param
+      }.to_json
+    end
+
+    # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+    #
+    # @param obj [Object]
+    # @return [Void]
+    def self.validate_raw(obj:)
+      obj.type.is_a?(ERROR_SCHEMA_ERROR_TYPE) != false || raise("Passed value for field obj.type is not the expected type, validation failed.")
+      obj.message.is_a?(String) != false || raise("Passed value for field obj.message is not the expected type, validation failed.")
+      obj.code.is_a?(ERROR_SCHEMA_ERROR_CODE) != false || raise("Passed value for field obj.code is not the expected type, validation failed.")
+      obj.param&.is_a?(String) != false || raise("Passed value for field obj.param is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/intrinsic/types/error_schema_error_code.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Intrinsic
+  # @type [ERROR_SCHEMA_ERROR_CODE]
+  ERROR_SCHEMA_ERROR_CODE = {
+    four_hundred: "400",
+    four_hundred_one: "401",
+    four_hundred_three: "403",
+    four_hundred_four: "404",
+    five_hundred: "500",
+    five_hundred_one: "501"
+  }.freeze
+end

data/lib/intrinsic/types/error_schema_error_type.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Intrinsic
+  # @type [ERROR_SCHEMA_ERROR_TYPE]
+  ERROR_SCHEMA_ERROR_TYPE = {
+    invalid_request_error: "invalid_request_error",
+    not_enabled_error: "not_enabled_error",
+    rate_limit_error: "rate_limit_error",
+    authentication_error: "authentication_error",
+    not_found_error: "not_found_error",
+    internal_server_error: "internal_server_error"
+  }.freeze
+end

data/lib/intrinsic/types/event_type_field.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "event_type_field_type"
+require "json"
+
+module Intrinsic
+  class EventTypeField
+    attr_reader :field_name, :type, :optional, :additional_properties
+
+    # @param field_name [String] Name of the field. Must be unique, and can only contain alphanumeric characters and underscores, and be up to 255 characters
+    # @param type [EVENT_TYPE_FIELD_TYPE] Type of the field. Can be either strings, numbers, links to JPEG images, or links to video files
+    # @param optional [Boolean] Whether the field is optional or not
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [EventTypeField]
+    def initialize(field_name:, type:, optional:, additional_properties: nil)
+      # @type [String] Name of the field. Must be unique, and can only contain alphanumeric characters and underscores, and be up to 255 characters
+      @field_name = field_name
+      # @type [EVENT_TYPE_FIELD_TYPE] Type of the field. Can be either strings, numbers, links to JPEG images, or links to video files
+      @type = type
+      # @type [Boolean] Whether the field is optional or not
+      @optional = optional
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of EventTypeField
+    #
+    # @param json_object [JSON]
+    # @return [EventTypeField]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      field_name = struct.field_name
+      type = EVENT_TYPE_FIELD_TYPE.key(parsed_json["type"]) || parsed_json["type"]
+      optional = struct.optional
+      new(field_name: field_name, type: type, optional: optional, additional_properties: struct)
+    end
+
+    # Serialize an instance of EventTypeField to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "field_name": @field_name, "type": EVENT_TYPE_FIELD_TYPE[@type] || @type, "optional": @optional }.to_json
+    end
+
+    # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+    #
+    # @param obj [Object]
+    # @return [Void]
+    def self.validate_raw(obj:)
+      obj.field_name.is_a?(String) != false || raise("Passed value for field obj.field_name is not the expected type, validation failed.")
+      obj.type.is_a?(EVENT_TYPE_FIELD_TYPE) != false || raise("Passed value for field obj.type is not the expected type, validation failed.")
+      obj.optional.is_a?(Boolean) != false || raise("Passed value for field obj.optional is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/intrinsic/types/event_type_field_type.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Intrinsic
+  # @type [EVENT_TYPE_FIELD_TYPE]
+  EVENT_TYPE_FIELD_TYPE = {
+    string: "string",
+    number: "number",
+    image_url: "image_url",
+    video_url: "video_url",
+    text_content: "text_content"
+  }.freeze
+end

data/lib/intrinsic/types/event_type_object.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "event_type_field"
+require "json"
+
+module Intrinsic
+  class EventTypeObject
+    attr_reader :id, :name, :fields, :object, :additional_properties
+
+    # @param id [String] ID of the event type
+    # @param name [String] Name of the event type. Must be unique, and can only contain alphanumeric characters and underscores, and be up to 255 characters
+    # @param fields [Array<EventTypeField>] Fields of the event type
+    # @param object [String]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [EventTypeObject]
+    def initialize(id:, name:, fields:, object:, additional_properties: nil)
+      # @type [String] ID of the event type
+      @id = id
+      # @type [String] Name of the event type. Must be unique, and can only contain alphanumeric characters and underscores, and be up to 255 characters
+      @name = name
+      # @type [Array<EventTypeField>] Fields of the event type
+      @fields = fields
+      # @type [String]
+      @object = object
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of EventTypeObject
+    #
+    # @param json_object [JSON]
+    # @return [EventTypeObject]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      id = struct.id
+      name = struct.name
+      fields = parsed_json["fields"]&.map do |v|
+        v = v.to_json
+        EventTypeField.from_json(json_object: v)
+      end
+      object = struct.object
+      new(id: id, name: name, fields: fields, object: object, additional_properties: struct)
+    end
+
+    # Serialize an instance of EventTypeObject to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "id": @id, "name": @name, "fields": @fields, "object": @object }.to_json
+    end
+
+    # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+    #
+    # @param obj [Object]
+    # @return [Void]
+    def self.validate_raw(obj:)
+      obj.id.is_a?(String) != false || raise("Passed value for field obj.id is not the expected type, validation failed.")
+      obj.name.is_a?(String) != false || raise("Passed value for field obj.name is not the expected type, validation failed.")
+      obj.fields.is_a?(Array) != false || raise("Passed value for field obj.fields is not the expected type, validation failed.")
+      obj.object.is_a?(String) != false || raise("Passed value for field obj.object is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/intrinsic/types/fired_rule_object.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Intrinsic
+  class FiredRuleObject
+    attr_reader :object, :rule_id, :rule_name, :triggered_action_name, :additional_properties
+
+    # @param object [String]
+    # @param rule_id [String] ID of the fired rule
+    # @param rule_name [String] Name of the fired rule
+    # @param triggered_action_name [String] Name of the triggered action
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [FiredRuleObject]
+    def initialize(object:, rule_id:, rule_name:, triggered_action_name:, additional_properties: nil)
+      # @type [String]
+      @object = object
+      # @type [String] ID of the fired rule
+      @rule_id = rule_id
+      # @type [String] Name of the fired rule
+      @rule_name = rule_name
+      # @type [String] Name of the triggered action
+      @triggered_action_name = triggered_action_name
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of FiredRuleObject
+    #
+    # @param json_object [JSON]
+    # @return [FiredRuleObject]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      JSON.parse(json_object)
+      object = struct.object
+      rule_id = struct.rule_id
+      rule_name = struct.rule_name
+      triggered_action_name = struct.triggered_action_name
+      new(object: object, rule_id: rule_id, rule_name: rule_name, triggered_action_name: triggered_action_name,
+          additional_properties: struct)
+    end
+
+    # Serialize an instance of FiredRuleObject to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      {
+        "object": @object,
+        "rule_id": @rule_id,
+        "rule_name": @rule_name,
+        "triggered_action_name": @triggered_action_name
+      }.to_json
+    end
+
+    # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+    #
+    # @param obj [Object]
+    # @return [Void]
+    def self.validate_raw(obj:)
+      obj.object.is_a?(String) != false || raise("Passed value for field obj.object is not the expected type, validation failed.")
+      obj.rule_id.is_a?(String) != false || raise("Passed value for field obj.rule_id is not the expected type, validation failed.")
+      obj.rule_name.is_a?(String) != false || raise("Passed value for field obj.rule_name is not the expected type, validation failed.")
+      obj.triggered_action_name.is_a?(String) != false || raise("Passed value for field obj.triggered_action_name is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/intrinsic/types/list_event_types_response.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "event_type_object"
+require "json"
+
+module Intrinsic
+  class ListEventTypesResponse
+    attr_reader :data, :object, :additional_properties
+
+    # @param data [Array<EventTypeObject>]
+    # @param object [String]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [ListEventTypesResponse]
+    def initialize(data:, object:, additional_properties: nil)
+      # @type [Array<EventTypeObject>]
+      @data = data
+      # @type [String]
+      @object = object
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of ListEventTypesResponse
+    #
+    # @param json_object [JSON]
+    # @return [ListEventTypesResponse]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      data = parsed_json["data"]&.map do |v|
+        v = v.to_json
+        EventTypeObject.from_json(json_object: v)
+      end
+      object = struct.object
+      new(data: data, object: object, additional_properties: struct)
+    end
+
+    # Serialize an instance of ListEventTypesResponse to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "data": @data, "object": @object }.to_json
+    end
+
+    # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+    #
+    # @param obj [Object]
+    # @return [Void]
+    def self.validate_raw(obj:)
+      obj.data.is_a?(Array) != false || raise("Passed value for field obj.data is not the expected type, validation failed.")
+      obj.object.is_a?(String) != false || raise("Passed value for field obj.object is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/intrinsic/types/violated_policy_object.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Intrinsic
+  class ViolatedPolicyObject
+    attr_reader :object, :id, :version_id, :name, :explanation, :additional_properties
+
+    # @param object [String]
+    # @param id [String] ID of the policy that was violated
+    # @param version_id [String] Version of the policy that was violated
+    # @param name [String] Name of the policy
+    # @param explanation [String] Explanation for why policy was violated
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [ViolatedPolicyObject]
+    def initialize(object:, id:, name:, explanation:, version_id: nil, additional_properties: nil)
+      # @type [String]
+      @object = object
+      # @type [String] ID of the policy that was violated
+      @id = id
+      # @type [String] Version of the policy that was violated
+      @version_id = version_id
+      # @type [String] Name of the policy
+      @name = name
+      # @type [String] Explanation for why policy was violated
+      @explanation = explanation
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of ViolatedPolicyObject
+    #
+    # @param json_object [JSON]
+    # @return [ViolatedPolicyObject]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      JSON.parse(json_object)
+      object = struct.object
+      id = struct.id
+      version_id = struct.version_id
+      name = struct.name
+      explanation = struct.explanation
+      new(object: object, id: id, version_id: version_id, name: name, explanation: explanation,
+          additional_properties: struct)
+    end
+
+    # Serialize an instance of ViolatedPolicyObject to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "object": @object, "id": @id, "version_id": @version_id, "name": @name, "explanation": @explanation }.to_json
+    end
+
+    # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+    #
+    # @param obj [Object]
+    # @return [Void]
+    def self.validate_raw(obj:)
+      obj.object.is_a?(String) != false || raise("Passed value for field obj.object is not the expected type, validation failed.")
+      obj.id.is_a?(String) != false || raise("Passed value for field obj.id is not the expected type, validation failed.")
+      obj.version_id&.is_a?(String) != false || raise("Passed value for field obj.version_id is not the expected type, validation failed.")
+      obj.name.is_a?(String) != false || raise("Passed value for field obj.name is not the expected type, validation failed.")
+      obj.explanation.is_a?(String) != false || raise("Passed value for field obj.explanation is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/intrinsic.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "environment"
+require_relative "types_export"
+require_relative "requests"
+require_relative "intrinsic/detections/client"
+require_relative "intrinsic/events/client"
+require_relative "intrinsic/event_types/client"
+
+module Intrinsic
+  class Client
+    attr_reader :detections, :events, :event_types
+
+    # @param environment [Environment]
+    # @param max_retries [Long] The number of times to retry a failed request, defaults to 2.
+    # @param timeout_in_seconds [Long]
+    # @param api_key [String]
+    # @return [Client]
+    def initialize(api_key:, environment: Environment::DEFAULT, max_retries: nil, timeout_in_seconds: nil)
+      @request_client = RequestClient.new(environment: environment, max_retries: max_retries,
+                                          timeout_in_seconds: timeout_in_seconds, api_key: api_key)
+      @detections = DetectionsClient.new(request_client: @request_client)
+      @events = EventsClient.new(request_client: @request_client)
+      @event_types = EventTypesClient.new(request_client: @request_client)
+    end
+  end
+
+  class AsyncClient
+    attr_reader :detections, :events, :event_types
+
+    # @param environment [Environment]
+    # @param max_retries [Long] The number of times to retry a failed request, defaults to 2.
+    # @param timeout_in_seconds [Long]
+    # @param api_key [String]
+    # @return [AsyncClient]
+    def initialize(api_key:, environment: Environment::DEFAULT, max_retries: nil, timeout_in_seconds: nil)
+      @async_request_client = AsyncRequestClient.new(environment: environment, max_retries: max_retries,
+                                                     timeout_in_seconds: timeout_in_seconds, api_key: api_key)
+      @detections = AsyncDetectionsClient.new(request_client: @async_request_client)
+      @events = AsyncEventsClient.new(request_client: @async_request_client)
+      @event_types = AsyncEventTypesClient.new(request_client: @async_request_client)
+    end
+  end
+end

data/lib/requests.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative "environment"
+require "faraday"
+require "faraday/retry"
+require "async/http/faraday"
+
+module Intrinsic
+  class RequestClient
+    attr_reader :headers, :base_url, :conn
+
+    # @param environment [Environment]
+    # @param max_retries [Long] The number of times to retry a failed request, defaults to 2.
+    # @param timeout_in_seconds [Long]
+    # @param api_key [String]
+    # @return [RequestClient]
+    def initialize(api_key:, environment: Environment::DEFAULT, max_retries: nil, timeout_in_seconds: nil)
+      @default_environment = environment
+      @base_url = environment
+      @headers = {
+        "X-Fern-Language": "Ruby",
+        "X-Fern-SDK-Name": "Intrinsic",
+        "X-Fern-SDK-Version": "0.0.2",
+        "X-API-Key": api_key.to_s
+      }
+      @conn = Faraday.new(@base_url, headers: @headers) do |faraday|
+        faraday.request :json
+        faraday.response :raise_error, include_request: true
+        faraday.request :retry, { max: max_retries } unless max_retries.nil?
+        faraday.options.timeout = timeout_in_seconds unless timeout_in_seconds.nil?
+      end
+    end
+  end
+
+  class AsyncRequestClient
+    attr_reader :headers, :base_url, :conn
+
+    # @param environment [Environment]
+    # @param max_retries [Long] The number of times to retry a failed request, defaults to 2.
+    # @param timeout_in_seconds [Long]
+    # @param api_key [String]
+    # @return [AsyncRequestClient]
+    def initialize(api_key:, environment: Environment::DEFAULT, max_retries: nil, timeout_in_seconds: nil)
+      @default_environment = environment
+      @base_url = environment
+      @headers = {
+        "X-Fern-Language": "Ruby",
+        "X-Fern-SDK-Name": "Intrinsic",
+        "X-Fern-SDK-Version": "0.0.2",
+        "X-API-Key": api_key.to_s
+      }
+      @conn = Faraday.new(@base_url, headers: @headers) do |faraday|
+        faraday.request :json
+        faraday.response :raise_error, include_request: true
+        faraday.adapter :async_http
+        faraday.request :retry, { max: max_retries } unless max_retries.nil?
+        faraday.options.timeout = timeout_in_seconds unless timeout_in_seconds.nil?
+      end
+    end
+  end
+
+  # Additional options for request-specific configuration when calling APIs via the SDK.
+  class RequestOptions
+    attr_reader :api_key, :additional_headers, :additional_query_parameters, :additional_body_parameters,
+                :timeout_in_seconds
+
+    # @param api_key [String]
+    # @param additional_headers [Hash{String => Object}]
+    # @param additional_query_parameters [Hash{String => Object}]
+    # @param additional_body_parameters [Hash{String => Object}]
+    # @param timeout_in_seconds [Long]
+    # @return [RequestOptions]
+    def initialize(api_key: nil, additional_headers: nil, additional_query_parameters: nil,
+                   additional_body_parameters: nil, timeout_in_seconds: nil)
+      # @type [String]
+      @api_key = api_key
+      # @type [Hash{String => Object}]
+      @additional_headers = additional_headers
+      # @type [Hash{String => Object}]
+      @additional_query_parameters = additional_query_parameters
+      # @type [Hash{String => Object}]
+      @additional_body_parameters = additional_body_parameters
+      # @type [Long]
+      @timeout_in_seconds = timeout_in_seconds
+    end
+  end
+end

data/lib/types_export.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "intrinsic/types/list_event_types_response"
+require_relative "intrinsic/types/event_type_object"
+require_relative "intrinsic/types/event_type_field_type"
+require_relative "intrinsic/types/event_type_field"
+require_relative "intrinsic/types/create_event_sync_request"
+require_relative "intrinsic/types/create_event_sync_response"
+require_relative "intrinsic/types/create_event_async_request"
+require_relative "intrinsic/types/create_event_async_response"
+require_relative "intrinsic/types/fired_rule_object"
+require_relative "intrinsic/types/detection_object_status"
+require_relative "intrinsic/types/detection_object"
+require_relative "intrinsic/types/violated_policy_object"
+require_relative "intrinsic/types/error_schema_error_type"
+require_relative "intrinsic/types/error_schema_error_code"
+require_relative "intrinsic/types/error_schema_error"
+require_relative "intrinsic/types/error_schema"