amazonica.aws.kinesis — com.signal-ai/amazonica 0.3.167-signal-4

*shard-id* clj

add-tags-to-stream clj

(add-tags-to-stream & {:keys [stream-name tags] :as add-tags-to-stream-request})

client-class clj

create-stream clj

(create-stream &
               {:keys [shard-count stream-mode-details stream-name]
                :as create-stream-request})

(create-stream string integer)

decrease-stream-retention-period clj

(decrease-stream-retention-period &
                                  {:keys [retention-period-hours stream-name]
                                   :as
                                     decrease-stream-retention-period-request})

delete-stream clj

(delete-stream & {:keys [blank bytes empty] :as string})

(delete-stream &
               {:keys [enforce-consumer-deletion stream-name]
                :as delete-stream-request})

deregister-stream-consumer clj

(deregister-stream-consumer &
                            {:keys [consumer-arn consumer-name stream-arn]
                             :as deregister-stream-consumer-request})

describe-limits clj

(describe-limits & {:keys [] :as describe-limits-request})

describe-stream clj

(describe-stream & {:keys [blank bytes empty] :as string})

(describe-stream &
                 {:keys [exclusive-start-shard-id limit stream-name]
                  :as describe-stream-request})

(describe-stream string-1 string-2)

(describe-stream string-1 integer string-2)

describe-stream-consumer clj

(describe-stream-consumer &
                          {:keys [consumer-arn consumer-name stream-arn]
                           :as describe-stream-consumer-request})

describe-stream-summary clj

(describe-stream-summary &
                         {:keys [stream-name]
                          :as describe-stream-summary-request})

disable-enhanced-monitoring clj

(disable-enhanced-monitoring &
                             {:keys [shard-level-metrics stream-name]
                              :as disable-enhanced-monitoring-request})

enable-enhanced-monitoring clj

(enable-enhanced-monitoring &
                            {:keys [shard-level-metrics stream-name]
                             :as enable-enhanced-monitoring-request})

get-cached-response-metadata clj

(get-cached-response-metadata & [amazon-web-service-request])

get-records clj

(get-records & {:keys [limit shard-iterator] :as get-records-request})

get-shard-iterator clj

(get-shard-iterator &
                    {:keys [shard-id shard-iterator-type
                            starting-sequence-number stream-name timestamp]
                     :as get-shard-iterator-request})

(get-shard-iterator string-1 string-2 string-3)

(get-shard-iterator string-1 string-2 string-3 string-4)

increase-stream-retention-period clj

(increase-stream-retention-period &
                                  {:keys [retention-period-hours stream-name]
                                   :as
                                     increase-stream-retention-period-request})

list-shards clj

(list-shards &
             {:keys [exclusive-start-shard-id max-results next-token
                     shard-filter stream-creation-timestamp stream-name]
              :as list-shards-request})

list-stream-consumers clj

(list-stream-consumers &
                       {:keys [max-results next-token stream-arn
                               stream-creation-timestamp]
                        :as list-stream-consumers-request})

list-streams clj

(list-streams)

(list-streams & {:keys [blank bytes empty] :as string})

(list-streams &
              {:keys [exclusive-start-stream-name limit]
               :as list-streams-request})

(list-streams integer string)

list-tags-for-stream clj

(list-tags-for-stream &
                      {:keys [exclusive-start-tag-key limit stream-name]
                       :as list-tags-for-stream-request})

marshall clj

(marshall deserializer record)

merge-shards clj

(merge-shards &
              {:keys [adjacent-shard-to-merge shard-to-merge stream-name]
               :as merge-shards-request})

(merge-shards string-1 string-2 string-3)

put-record clj

(put-record &
            {:keys [data explicit-hash-key partition-key
                    sequence-number-for-ordering stream-name]
             :as put-record-request})

(put-record string-1 byte-buffer string-2)

(put-record string-1 byte-buffer string-2 string-3)

put-records clj

(put-records & {:keys [records stream-name] :as put-records-request})

register-stream-consumer clj

(register-stream-consumer &
                          {:keys [consumer-name stream-arn]
                           :as register-stream-consumer-request})

remove-tags-from-stream clj

(remove-tags-from-stream &
                         {:keys [stream-name tag-keys]
                          :as remove-tags-from-stream-request})

show-functions clj

shutdown clj

(shutdown)

split-shard clj

(split-shard &
             {:keys [new-starting-hash-key shard-to-split stream-name]
              :as split-shard-request})

(split-shard string-1 string-2 string-3)

start-stream-encryption clj

(start-stream-encryption &
                         {:keys [encryption-type key-id stream-name]
                          :as start-stream-encryption-request})

stop-stream-encryption clj

(stop-stream-encryption &
                        {:keys [encryption-type key-id stream-name]
                         :as stop-stream-encryption-request})

unwrap clj

(unwrap byte-buffer)

Get the contents of the given buffer as a byte-array, decoding as Nippy bytes if they appear to be Nippy encoded. If the ByteBuffer does not appear to contain Nippy data, the bytes found will be returned unchanged. This technique is inspired by ptaoussanis/faraday.

update-shard-count clj

(update-shard-count &
                    {:keys [scaling-type stream-name target-shard-count]
                     :as update-shard-count-request})

update-stream-mode clj

(update-stream-mode &
                    {:keys [stream-arn stream-mode-details]
                     :as update-stream-mode-request})

waiters clj

(waiters)

worker clj

(worker & args)

Instantiate a kinesis Worker.

worker! clj

(worker! & args)

Instantiate a new kinesis Worker and invoke its run method in a separate thread. Return the identifier of the Worker.