wavify 0.1.0 → 0.2.0

data/sig/codecs.rbs

@@ -0,0 +1,77 @@
+module Wavify
+  module Codecs
+    class Base
+      def self.available?: () -> bool
+      def self.can_read?: (String | IO io_or_path) -> bool
+      def self.read: (String | IO io_or_path, **untyped options) -> Core::SampleBuffer
+      def self.write: (String | IO io_or_path, Core::SampleBuffer sample_buffer, **untyped options) -> untyped
+      def self.stream_read: (String | IO io_or_path, **untyped options) { (Core::SampleBuffer) -> void } -> untyped
+      def self.stream_write: (String | IO io_or_path, **untyped options) { (untyped) -> void } -> untyped
+      def self.metadata: (String | IO io_or_path, **untyped options) -> Hash[Symbol, untyped]
+    end
+
+    class Wav < Base
+      def self.can_read?: (String | IO io_or_path) -> bool
+      def self.read: (String | IO io_or_path, ?format: Core::Format?, ?warning_io: IO?) -> Core::SampleBuffer
+      def self.write: (String | IO io_or_path, Core::SampleBuffer sample_buffer, ?format: Core::Format?, ?info: Hash[Symbol, untyped]?, **untyped codec_options) -> Core::SampleBuffer
+      def self.stream_read: (String | IO io_or_path, ?chunk_size: Integer, ?warning_io: IO?) { (Core::SampleBuffer) -> void } -> Core::Format
+      def self.stream_write: (String | IO io_or_path, format: Core::Format, ?info: Hash[Symbol, untyped]?, **untyped codec_options) { (untyped) -> void } -> untyped
+      def self.metadata: (String | IO io_or_path) -> Hash[Symbol, untyped]
+    end
+
+    class Aiff < Base
+      def self.can_read?: (String | IO io_or_path) -> bool
+      def self.read: (String | IO io_or_path, ?format: Core::Format?, ?warning_io: IO?) -> Core::SampleBuffer
+      def self.write: (String | IO io_or_path, Core::SampleBuffer sample_buffer, ?format: Core::Format?, **untyped options) -> Core::SampleBuffer
+      def self.stream_read: (String | IO io_or_path, ?chunk_size: Integer, ?warning_io: IO?) { (Core::SampleBuffer) -> void } -> Core::Format
+      def self.stream_write: (String | IO io_or_path, format: Core::Format, **untyped options) { (untyped) -> void } -> untyped
+      def self.metadata: (String | IO io_or_path) -> Hash[Symbol, untyped]
+    end
+
+    class Flac < Base
+      def self.can_read?: (String | IO io_or_path) -> bool
+      def self.read: (String | IO io_or_path, ?format: Core::Format?) -> Core::SampleBuffer
+      def self.write: (String | IO io_or_path, Core::SampleBuffer sample_buffer, format: Core::Format, **untyped options) -> Core::SampleBuffer
+      def self.stream_read: (String | IO io_or_path, ?chunk_size: Integer) { (Core::SampleBuffer) -> void } -> Core::Format
+      def self.stream_write: (String | IO io_or_path, format: Core::Format, **untyped options) { (untyped) -> void } -> untyped
+      def self.metadata: (String | IO io_or_path) -> Hash[Symbol, untyped]
+    end
+
+    class OggVorbis < Base
+      def self.available?: () -> bool
+      def self.runtime_diagnostics: () -> Hash[Symbol, untyped]
+      def self.can_read?: (String | IO io_or_path) -> bool
+      def self.read: (String | IO io_or_path, ?format: Core::Format?, ?mix_strategy: Symbol) -> Core::SampleBuffer
+      def self.write: (String | IO io_or_path, Core::SampleBuffer sample_buffer, format: Core::Format, ?quality: Numeric, **untyped options) -> Core::SampleBuffer
+      def self.stream_read: (String | IO io_or_path, ?chunk_size: Integer, ?mix_strategy: Symbol) { (Core::SampleBuffer) -> void } -> Core::Format
+      def self.stream_write: (String | IO io_or_path, format: Core::Format, ?quality: Numeric, **untyped options) { (untyped) -> void } -> untyped
+      def self.metadata: (String | IO io_or_path) -> Hash[Symbol, untyped]
+    end
+
+    class Raw < Base
+      def self.can_read?: (String | IO io_or_path) -> bool
+      def self.read: (String | IO io_or_path, ?format: Core::Format?, ?endianness: Symbol, ?signed: bool?, ?float_domain: Symbol, **untyped options) -> Core::SampleBuffer
+      def self.write: (String | IO io_or_path, Core::SampleBuffer sample_buffer, format: Core::Format, ?endianness: Symbol, ?signed: bool?, ?float_domain: Symbol, **untyped options) -> String | IO
+      def self.stream_read: (String | IO io_or_path, format: Core::Format, ?chunk_size: Integer, ?endianness: Symbol, ?signed: bool?, ?float_domain: Symbol, **untyped options) { (Core::SampleBuffer) -> void } -> nil
+      def self.stream_write: (String | IO io_or_path, format: Core::Format, ?endianness: Symbol, ?signed: bool?, ?float_domain: Symbol, **untyped options) { (untyped) -> void } -> String | IO
+      def self.metadata: (String | IO io_or_path, format: Core::Format, ?endianness: Symbol, ?signed: bool?, ?float_domain: Symbol, **untyped options) -> Hash[Symbol, untyped]
+    end
+
+    class Registry
+      def self.detect: (String | IO io_or_path, ?strict: bool, ?filename: String?) -> singleton(Base)
+      def self.detect_for_read: (String | IO io_or_path, ?strict: bool, ?filename: String?) -> singleton(Base)
+      def self.detect_for_write: (String | IO io_or_path, ?filename: String?) -> singleton(Base)
+      def self.resolve: (String | Symbol | singleton(Base) codec) -> singleton(Base)
+      def self.register: (String extension, singleton(Base) codec, ?magic: String | untyped, ?priority: Integer, ?probe_size: Integer) -> singleton(Base)
+      def self.unregister: (String extension) -> singleton(Base)?
+      def self.supported_formats: () -> Array[String]
+      def self.available_formats: () -> Array[String]
+    end
+
+    def self.detect: (String | IO io_or_path, ?strict: bool, ?filename: String?) -> singleton(Base)
+    def self.register: (String extension, singleton(Base) codec, **untyped options) -> singleton(Base)
+    def self.unregister: (String extension) -> singleton(Base)?
+    def self.supported_formats: () -> Array[String]
+    def self.available_formats: () -> Array[String]
+  end
+end

data/sig/core.rbs

@@ -0,0 +1,108 @@
+module Wavify
+  module Core
+    class Duration
+      include Comparable[Duration]
+
+      attr_reader total_seconds: Float
+
+      def self.from_samples: (Integer sample_frames, Integer sample_rate) -> Duration
+      def self.parse: (String value) -> Duration
+      def initialize: (Numeric total_seconds) -> void
+      def <=>: (Duration other) -> Integer?
+      def eql?: (untyped other) -> bool
+      def hash: () -> Integer
+      def +: (Duration other) -> Duration
+      def -: (Duration other) -> Duration
+      def hours: () -> Integer
+      def minutes: () -> Integer
+      def seconds: () -> Integer
+      def milliseconds: () -> Integer
+      def to_s: () -> String
+    end
+
+    class Format
+      attr_reader channels: Integer
+      attr_reader sample_rate: Integer
+      attr_reader bit_depth: Integer
+      attr_reader valid_bits: Integer
+      attr_reader sample_format: Symbol
+      attr_reader channel_layout: Array[Symbol]?
+
+      def initialize: (channels: Integer, sample_rate: Integer, bit_depth: Integer, ?sample_format: Symbol, ?valid_bits: Integer?, ?channel_layout: Array[Symbol] | :unknown | nil) -> void
+      def with: (?channels: Integer?, ?sample_rate: Integer?, ?bit_depth: Integer?, ?sample_format: Symbol?, ?valid_bits: Integer?, ?channel_layout: Array[Symbol] | :unknown | nil) -> Format
+      def mono?: () -> bool
+      def stereo?: () -> bool
+      def block_align: () -> Integer
+      def byte_rate: () -> Integer
+      def bytes_per_sample: () -> Integer
+      def ==: (untyped other) -> bool
+      def eql?: (untyped other) -> bool
+      def hash: () -> Integer
+    end
+
+    class SampleBuffer
+      class FrameView
+        include Enumerable[Array[Numeric]]
+
+        attr_reader channels: Integer
+        attr_reader frame_count: Integer
+
+        def initialize: (Array[Numeric] samples, Integer channels, ?start_frame: Integer, ?frame_count: Integer?) -> void
+        def each: () { (Array[Numeric]) -> void } -> FrameView
+                | () -> Enumerator[Array[Numeric], FrameView]
+        def []: (Integer index) -> Array[Numeric]?
+        def slice: (Integer start_frame, Integer frame_length) -> FrameView
+        def length: () -> Integer
+      end
+
+      class View
+        include Enumerable[Numeric]
+
+        attr_reader format: Format
+        attr_reader duration: Duration
+
+        def initialize: (Array[Numeric] samples, Format format, ?start_frame: Integer, ?frame_count: Integer?) -> void
+        def each: () { (Numeric) -> void } -> View
+                | () -> Enumerator[Numeric, View]
+        def samples: () -> Array[Numeric]
+        def length: () -> Integer
+        def size: () -> Integer
+        def sample_frame_count: () -> Integer
+        def frame_view: () -> FrameView
+        def slice: (Integer start_frame, Integer frame_length) -> View
+        def to_sample_buffer: () -> SampleBuffer
+        def convert: (Format new_format, **untyped options) -> SampleBuffer
+      end
+
+      include Enumerable[Numeric]
+
+      attr_reader format: Format
+      attr_reader duration: Duration
+
+      def self.from_pcm_samples: (Array[Numeric] samples, Format format, ?storage: Symbol) -> SampleBuffer
+      def self.from_normalized_samples: (Array[Numeric] samples, Format format, ?storage: Symbol) -> SampleBuffer
+      def initialize: (Array[Numeric] samples, Format format, ?storage: Symbol) -> void
+      def samples: () -> Array[Numeric]
+      def each: () { (Numeric) -> void } -> SampleBuffer
+              | () -> Enumerator[Numeric, SampleBuffer]
+      def each_frame_sample: () { (Numeric, Integer, Integer) -> void } -> SampleBuffer
+                           | () -> Enumerator[Numeric, SampleBuffer]
+      def storage: () -> Symbol
+      def packed?: () -> bool
+      def packed_bytesize: () -> Integer
+      def length: () -> Integer
+      def size: () -> Integer
+      def sample_frame_count: () -> Integer
+      def frame_view: () -> FrameView
+      def view: (?start_frame: Integer, ?frame_length: Integer?) -> View
+      def convert: (Format new_format, ?dither: bool, ?dither_seed: Integer?, ?resampler: Symbol) -> SampleBuffer
+      def reverse: () -> SampleBuffer
+      def slice: (Integer start_frame, Integer frame_length) -> SampleBuffer
+      def concat: (SampleBuffer other) -> SampleBuffer
+      def +: (SampleBuffer other) -> SampleBuffer
+      def ==: (untyped other) -> bool
+      def eql?: (untyped other) -> bool
+      def hash: () -> Integer
+    end
+  end
+end

data/sig/dsl.rbs

@@ -0,0 +1,32 @@
+module Wavify
+  module DSL
+    class SongDefinition
+      attr_reader format: Core::Format
+      attr_reader tempo: Float
+      attr_reader beats_per_bar: Integer
+      attr_reader swing: Float
+      attr_reader tracks: Array[untyped]
+      attr_reader sections: Array[untyped]
+      attr_reader default_bars: Integer
+      attr_reader random_seed: Integer
+
+      def arrangement?: () -> bool
+      def engine: () -> Sequencer::Engine
+      def sequencer_tracks: () -> Array[Sequencer::Track]
+      def validate!: (?deep: bool) -> true
+      def arrangement: () -> Array[Hash[Symbol, untyped]]
+      def duration: (?default_bars: Integer) -> Core::Duration
+      def length: (?default_bars: Integer) -> Core::Duration
+      def timeline: (?default_bars: Integer) -> Array[Hash[Symbol, untyped]]
+      def timeline_json: (?default_bars: Integer) -> String
+      def timeline_text: (?default_bars: Integer) -> String
+      def render: (?default_bars: Integer, ?stems: bool) -> Audio | Hash[Symbol, Audio]
+      def write: (String path, ?default_bars: Integer) -> Audio
+      def write_stems: (String directory, ?default_bars: Integer, ?overwrite: bool) -> Hash[Symbol, String]
+    end
+
+    def self.build_definition: (format: Core::Format, ?tempo: Numeric, ?beats_per_bar: Integer, ?swing: Numeric, ?default_bars: Integer, ?random_seed: Integer) { () -> void } -> SongDefinition
+    def self.validate: (format: Core::Format, ?tempo: Numeric, ?beats_per_bar: Integer, ?swing: Numeric, ?default_bars: Integer, ?random_seed: Integer) { () -> void } -> true
+    def self.effect: (String | Symbol name, **untyped params) -> untyped
+  end
+end

data/sig/dsp.rbs

@@ -0,0 +1,87 @@
+module Wavify
+  module DSP
+    module Processor
+      def self.build_runtime: (untyped processor) -> untyped
+      def self.process: (untyped processor, Core::SampleBuffer buffer) -> Core::SampleBuffer
+      def self.flush: (untyped processor, ?format: Core::Format?) -> Enumerator[Core::SampleBuffer, nil]
+      def self.render: (untyped processor, Core::SampleBuffer buffer) -> Core::SampleBuffer
+      def self.duration: (untyped processor, Symbol method_name) -> Float
+    end
+
+    module Headroom
+      def self.apply!: (Array[Numeric] samples, ?strategy: Symbol, ?format: Core::Format?, ?smoothing: Numeric) -> Array[Numeric]
+    end
+
+    class Automation
+      attr_reader points: Array[[Float, Float]]
+
+      def initialize: (Array[untyped] points) -> void
+      def value_at: (Numeric time) -> Float
+      def apply: (Core::SampleBuffer buffer) { (Numeric, Float, Integer) -> Numeric } -> Core::SampleBuffer
+      def apply_gain: (Core::SampleBuffer buffer, ?unit: Symbol) -> Core::SampleBuffer
+    end
+
+    class Envelope
+      attr_reader attack: Float
+      attr_reader hold: Float
+      attr_reader decay: Float
+      attr_reader sustain: Float
+      attr_reader release: Float
+      attr_reader curve: Symbol
+
+      def initialize: (attack: Numeric, decay: Numeric, sustain: Numeric, release: Numeric, ?hold: Numeric, ?curve: Symbol) -> void
+      def gain_at: (Numeric time, note_on_duration: Numeric) -> Float
+      def apply: (Core::SampleBuffer buffer, note_on_duration: Numeric) -> Core::SampleBuffer
+      def render_with_tail: (Core::SampleBuffer buffer, note_on_duration: Numeric) -> Core::SampleBuffer
+      def tail_duration: () -> Float
+      def latency: () -> Float
+      def lookahead: () -> Float
+    end
+
+    class Filter
+      attr_reader type: Symbol
+      attr_reader cutoff: Float
+      attr_reader q: Float
+      attr_reader gain_db: Float
+
+      def self.lowpass: (cutoff: Numeric, ?q: Numeric) -> Filter
+      def self.highpass: (cutoff: Numeric, ?q: Numeric) -> Filter
+      def self.bandpass: (?center: Numeric?, ?bandwidth: Numeric?, ?cutoff: Numeric?, ?q: Numeric?) -> Filter
+      def self.notch: (cutoff: Numeric, ?q: Numeric) -> Filter
+      def self.peaking: (cutoff: Numeric, ?q: Numeric, ?gain_db: Numeric) -> Filter
+      def self.lowshelf: (cutoff: Numeric, gain_db: Numeric) -> Filter
+      def self.highshelf: (cutoff: Numeric, gain_db: Numeric) -> Filter
+      def initialize: (Symbol type, cutoff: Numeric, ?q: Numeric, ?gain_db: Numeric) -> void
+      def apply: (Core::SampleBuffer buffer) -> Core::SampleBuffer
+      def process: (Core::SampleBuffer buffer) -> Core::SampleBuffer
+      def process_sample: (Numeric sample, sample_rate: Integer, channel: Integer, channels: Integer) -> Float
+      def flush: (?format: Core::Format?) -> Core::SampleBuffer?
+      def reset: () -> Filter
+      def build_runtime: () -> Filter
+      def tail_duration: () -> Float
+      def latency: () -> Float
+      def lookahead: () -> Float
+    end
+
+    class LFO
+      def initialize: (rate: Numeric, sample_rate: Numeric, ?waveform: Symbol, ?phase: Numeric) -> void
+      def next_value: () -> Float
+      def value_at: (?Numeric offset) -> Float
+      def reset: () -> LFO
+    end
+
+    class LoudnessMeter
+      def self.integrated: (Array[Numeric] | Core::SampleBuffer samples, ?sample_rate: Integer?, ?channels: Integer?, ?format: Core::Format?, ?channel_layout: Array[Symbol]?) -> Float
+      def self.momentary: (Array[Numeric] | Core::SampleBuffer samples, ?sample_rate: Integer?, ?channels: Integer?, ?format: Core::Format?, ?channel_layout: Array[Symbol]?) -> Float
+      def self.short_term: (Array[Numeric] | Core::SampleBuffer samples, ?sample_rate: Integer?, ?channels: Integer?, ?format: Core::Format?, ?channel_layout: Array[Symbol]?) -> Float
+      def self.true_peak: (Array[Numeric] | Core::SampleBuffer samples, ?sample_rate: Integer?, ?channels: Integer?, ?format: Core::Format?, ?oversampling: Integer) -> Float
+    end
+
+    class Oscillator
+      def initialize: (waveform: Symbol, frequency: Numeric, ?amplitude: Numeric, ?phase: Numeric, ?pulse_width: Numeric, ?detune: Numeric, ?unison: Integer, ?random: Random) -> void
+      def reset_phase: (?Numeric phase) -> Oscillator
+      def generate: (Numeric duration_seconds, format: Core::Format) -> Core::SampleBuffer
+      def each_sample: (format: Core::Format) -> Enumerator[Float, nil]
+    end
+  end
+end

data/sig/effects.rbs

@@ -0,0 +1,129 @@
+module Wavify
+  module DSP
+    module Effects
+      def self.register: (String | Symbol name, ?untyped factory) ?{ (**untyped) -> untyped } -> untyped
+      def self.unregister: (String | Symbol name) -> untyped
+      def self.build: (String | Symbol name, **untyped params) -> untyped
+      def self.registered_effects: () -> Hash[Symbol, untyped]
+
+      class EffectBase
+        def apply: (Core::SampleBuffer buffer) -> Core::SampleBuffer
+        def process: (Core::SampleBuffer buffer) -> Core::SampleBuffer
+        def flush: (?format: Core::Format?) -> Enumerator[Core::SampleBuffer, nil]?
+        def process_sample: (Numeric sample, channel: Integer, sample_rate: Integer) -> Numeric
+        def reset: () -> EffectBase
+        def build_runtime: () -> EffectBase
+        def tail_duration: () -> Float
+        def latency: () -> Float
+        def lookahead: () -> Float
+      end
+
+      class EffectChain
+        attr_reader effects: Array[untyped]
+
+        def initialize: (Array[untyped] effects) -> void
+        def apply: (Core::SampleBuffer buffer) -> Core::SampleBuffer
+        def process: (Core::SampleBuffer buffer) -> Core::SampleBuffer
+        def flush: (?format: Core::Format?) -> Enumerator[Core::SampleBuffer, nil]
+        def reset: () -> EffectChain
+        def build_runtime: () -> EffectChain
+        def tail_duration: () -> Float
+        def latency: () -> Float
+        def lookahead: () -> Float
+      end
+
+      class Delay < EffectBase
+        def self.beat: (Numeric bpm, ?division: Numeric) -> Float
+        def initialize: (?time: Numeric, ?feedback: Numeric, ?mix: Numeric, ?ping_pong: bool) -> void
+      end
+
+      class Reverb < EffectBase
+        def initialize: (?room_size: Numeric, ?damping: Numeric, ?mix: Numeric, ?pre_delay: Numeric, ?width: Numeric) -> void
+      end
+
+      class Chorus < EffectBase
+        def initialize: (?rate: Numeric, ?depth: Numeric, ?mix: Numeric, ?delay: Numeric, ?voices: Integer) -> void
+      end
+
+      class Distortion < EffectBase
+        def initialize: (?drive: Numeric, ?mix: Numeric, ?tone: Numeric) -> void
+      end
+
+      class Compressor < EffectBase
+        def initialize: (?threshold: Numeric, ?ratio: Numeric, ?attack: Numeric, ?release: Numeric, ?makeup_gain: Numeric, ?knee: Numeric, ?sidechain: Audio | Core::SampleBuffer?, ?sidechain_end: Symbol) -> void
+      end
+
+      class Limiter < EffectBase
+        def initialize: (?ceiling: Numeric, ?input_gain: Numeric, ?attack: Numeric, ?release: Numeric, ?lookahead: Numeric, ?oversampling: Integer) -> void
+      end
+
+      class SoftLimiter < EffectBase
+        def initialize: (?threshold: Numeric, ?ceiling: Numeric, ?drive: Numeric) -> void
+      end
+
+      class NoiseGate < EffectBase
+        def initialize: (?threshold: Numeric, ?floor: Numeric, ?attack: Numeric, ?hold: Numeric, ?release: Numeric, ?gain_attack: Numeric, ?gain_release: Numeric) -> void
+      end
+
+      class Tremolo < EffectBase
+        def initialize: (?rate: Numeric, ?depth: Numeric, ?mix: Numeric) -> void
+      end
+
+      class Vibrato < EffectBase
+        def initialize: (?rate: Numeric, ?depth: Numeric, ?mix: Numeric) -> void
+      end
+
+      class Flanger < EffectBase
+        def initialize: (?rate: Numeric, ?depth: Numeric, ?feedback: Numeric, ?mix: Numeric, ?delay: Numeric) -> void
+      end
+
+      class Phaser < EffectBase
+        def initialize: (?rate: Numeric, ?depth: Numeric, ?feedback: Numeric, ?mix: Numeric, ?stages: Integer) -> void
+      end
+
+      class Bitcrusher < EffectBase
+        def initialize: (?bits: Integer, ?sample_rate_reduction: Integer, ?mix: Numeric) -> void
+      end
+
+      class Expander < EffectBase
+        def initialize: (?threshold: Numeric, ?ratio: Numeric, ?floor: Numeric, ?attack: Numeric, ?hold: Numeric, ?release: Numeric, ?gain_attack: Numeric, ?gain_release: Numeric) -> void
+      end
+
+      class AutoPan < EffectBase
+        def initialize: (?rate: Numeric, ?depth: Numeric) -> void
+      end
+
+      class StereoWidener
+        def initialize: (?width: Numeric) -> void
+        def process: (Core::SampleBuffer buffer) -> Core::SampleBuffer
+        def apply: (Core::SampleBuffer buffer) -> Core::SampleBuffer
+        def reset: () -> StereoWidener
+        def build_runtime: () -> StereoWidener
+        def tail_duration: () -> Float
+        def latency: () -> Float
+        def lookahead: () -> Float
+      end
+
+      class EQ
+        def self.simple: (?low_gain: Numeric, ?mid_gain: Numeric, ?high_gain: Numeric) -> EQ
+        def initialize: (Array[DSP::Filter] filters) -> void
+        def apply: (Core::SampleBuffer buffer) -> Core::SampleBuffer
+        def process: (Core::SampleBuffer buffer) -> Core::SampleBuffer
+        def flush: (?format: Core::Format?) -> untyped
+        def reset: () -> EQ
+        def build_runtime: () -> EQ
+        def tail_duration: () -> Float
+        def latency: () -> Float
+        def lookahead: () -> Float
+      end
+
+      class MasteringChain < EffectChain
+        def initialize: (?highpass: Numeric, ?presence: Numeric, ?threshold: Numeric, ?ratio: Numeric, ?ceiling: Numeric) -> void
+      end
+
+      class PodcastChain < EffectChain
+        def initialize: (?gate_threshold: Numeric, ?highpass: Numeric, ?presence: Numeric, ?compression_threshold: Numeric, ?ceiling: Numeric) -> void
+      end
+    end
+  end
+end

data/sig/public_api.yml

@@ -0,0 +1,111 @@
+Wavify:
+  signature_file: wavify.rbs
+  class_methods: [build, ms, seconds]
+Wavify::Adapters:
+  signature_file: wavify.rbs
+  class_methods: [find, known, load]
+Wavify::Audio:
+  signature_file: audio.rbs
+  class_methods: [info, metadata, mix, read, silence, stream, tone]
+  instance_methods: ['+', '==', append, apply, apply!, balance, bit_depth, buffer, channels, clipped?, concat, convert, crop, crossfade, dc_offset, dc_offsets, duration, each_frame, eql?, fade, fade_in, fade_in!, fade_out, fade_out!, format, frames, gain, gain!, hash, insert_silence, inspect, lufs, map_frames, map_samples, normalize, normalize!, overlay, pad_end, pad_start, pan, pan!, peak_amplitude, peak_dbfs, prepend, remove_dc_offset, repeat, repeat!, repeat_chunks, resample, reverse, reverse!, rms_amplitude, rms_dbfs, sample_frame_count, sample_peak_amplitude, sample_peak_dbfs, sample_rate, silent?, slice, split, stats, stereo_rotate, to_mono, to_stereo, trim, trim!, true_peak_amplitude, true_peak_dbfs, with_bit_depth, write, zero_crossing_rate]
+Wavify::Core::Duration:
+  signature_file: core.rbs
+  class_methods: [from_samples, parse]
+  instance_methods: ['+', '-', '<=>', eql?, hash, hours, milliseconds, minutes, seconds, to_s, total_seconds]
+Wavify::Core::Format:
+  signature_file: core.rbs
+  instance_methods: ['==', bit_depth, block_align, byte_rate, bytes_per_sample, channel_layout, channels, eql?, hash, mono?, sample_format, sample_rate, stereo?, valid_bits, with]
+Wavify::Core::SampleBuffer:
+  signature_file: core.rbs
+  class_methods: [from_normalized_samples, from_pcm_samples]
+  instance_methods: ['+', '==', concat, convert, duration, each, each_frame_sample, eql?, format, frame_view, hash, length, packed?, packed_bytesize, reverse, sample_frame_count, samples, size, slice, storage, view]
+Wavify::Core::Stream:
+  signature_file: stream.rbs
+  instance_methods: [chunk_size, drop_duration, dry_run, each, each_chunk, format, latency, lookahead, map_chunks, meter, pipe, pipeline, pipeline_steps, progress, take_duration, tee, to_audio, write_to]
+Wavify::Codecs:
+  signature_file: codecs.rbs
+  class_methods: [available_formats, detect, register, supported_formats, unregister]
+Wavify::Codecs::Registry:
+  signature_file: codecs.rbs
+  class_methods: [available_formats, detect, detect_for_read, detect_for_write, register, resolve, supported_formats, unregister]
+Wavify::Codecs::Wav:
+  signature_file: codecs.rbs
+  class_methods: [can_read?, metadata, read, stream_read, stream_write, write]
+Wavify::Codecs::Aiff:
+  signature_file: codecs.rbs
+  class_methods: [can_read?, metadata, read, stream_read, stream_write, write]
+Wavify::Codecs::Flac:
+  signature_file: codecs.rbs
+  class_methods: [can_read?, metadata, read, stream_read, stream_write, write]
+Wavify::Codecs::OggVorbis:
+  signature_file: codecs.rbs
+  class_methods: [available?, can_read?, metadata, read, runtime_diagnostics, stream_read, stream_write, write]
+Wavify::Codecs::Raw:
+  signature_file: codecs.rbs
+  class_methods: [can_read?, metadata, read, stream_read, stream_write, write]
+Wavify::DSP::Processor:
+  signature_file: dsp.rbs
+  class_methods: [build_runtime, duration, flush, process, render]
+Wavify::DSP::Headroom:
+  signature_file: dsp.rbs
+  class_methods: [apply!]
+Wavify::DSP::Automation:
+  signature_file: dsp.rbs
+  instance_methods: [apply, apply_gain, points, value_at]
+Wavify::DSP::Envelope:
+  signature_file: dsp.rbs
+  instance_methods: [apply, attack, curve, decay, gain_at, hold, latency, lookahead, release, render_with_tail, sustain, tail_duration]
+Wavify::DSP::Filter:
+  signature_file: dsp.rbs
+  class_methods: [bandpass, highpass, highshelf, lowpass, lowshelf, notch, peaking]
+  instance_methods: [apply, build_runtime, cutoff, flush, gain_db, latency, lookahead, process, process_sample, q, reset, tail_duration, type]
+Wavify::DSP::LFO:
+  signature_file: dsp.rbs
+  instance_methods: [next_value, reset, value_at]
+Wavify::DSP::LoudnessMeter:
+  signature_file: dsp.rbs
+  class_methods: [integrated, momentary, short_term, true_peak]
+Wavify::DSP::Oscillator:
+  signature_file: dsp.rbs
+  instance_methods: [each_sample, generate, reset_phase]
+Wavify::DSP::Effects:
+  signature_file: effects.rbs
+  class_methods: [build, register, registered_effects, unregister]
+Wavify::DSP::Effects::EffectBase:
+  signature_file: effects.rbs
+  instance_methods: [apply, build_runtime, flush, latency, lookahead, process, process_sample, reset, tail_duration]
+Wavify::DSP::Effects::EffectChain:
+  signature_file: effects.rbs
+  instance_methods: [apply, build_runtime, effects, flush, latency, lookahead, process, reset, tail_duration]
+Wavify::DSP::Effects::Delay:
+  signature_file: effects.rbs
+  class_methods: [beat]
+Wavify::DSP::Effects::EQ:
+  signature_file: effects.rbs
+  class_methods: [simple]
+  instance_methods: [apply, build_runtime, flush, latency, lookahead, process, reset, tail_duration]
+Wavify::DSP::Effects::Limiter:
+  signature_file: effects.rbs
+  instance_methods: [apply, flush, latency, lookahead, process, process_sample, tail_duration]
+Wavify::DSP::Effects::StereoWidener:
+  signature_file: effects.rbs
+  instance_methods: [apply, build_runtime, latency, lookahead, process, reset, tail_duration]
+Wavify::Sequencer::Pattern:
+  signature_file: sequencer.rbs
+  instance_methods: ['[]', accented_indices, each, length, notation, resolution, size, steps, to_a, trigger_indices]
+Wavify::Sequencer::NoteSequence:
+  signature_file: sequencer.rbs
+  instance_methods: ['[]', default_octave, each, events, length, midi_notes, notation, note_events, size]
+Wavify::Sequencer::Track:
+  signature_file: sequencer.rbs
+  class_methods: [apply_chord_inversion, apply_chord_voicing, parse_chord_token, parse_chords, quantize_midi_note]
+  instance_methods: [chord_progression, chord_voicing, chords?, copy, default_octave, effects, effects?, envelope, event_sources?, gain_db, key_root, name, note_resolution, note_sequence, notes?, pan_position, parse_chords, pattern, pattern?, pattern_resolution, quantize_midi_note, scale, synth_options, waveform, with_chord_voicing, with_chords, with_effects, with_envelope, with_gain, with_key, with_notes, with_pan, with_pattern, with_synth]
+Wavify::Sequencer::Engine:
+  signature_file: sequencer.rbs
+  instance_methods: [bar_duration_seconds, beats_per_bar, build_timeline, expand_pattern_step, format, render, seconds_per_beat, step_duration_at, step_duration_seconds, step_start_seconds, swing, tempo, timeline_for_track]
+Wavify::DSL:
+  signature_file: dsl.rbs
+  class_methods: [build_definition, effect, validate]
+Wavify::DSL::SongDefinition:
+  signature_file: dsl.rbs
+  instance_methods: [arrangement, arrangement?, beats_per_bar, default_bars, duration, engine, format, length, random_seed, render, sections, sequencer_tracks, swing, tempo, timeline, timeline_json, timeline_text, tracks, validate!, write, write_stems]

data/sig/sequencer.rbs

@@ -0,0 +1,126 @@
+module Wavify
+  module Sequencer
+    class Pattern
+      class Step
+        attr_reader index: Integer
+        attr_reader trigger: bool
+        attr_reader accent: bool
+        attr_reader symbol: String
+        attr_reader velocity: Float
+        attr_reader probability: Float
+        attr_reader ratchet: Integer
+
+        def rest?: () -> bool
+        def trigger?: () -> bool
+        def accent?: () -> bool
+      end
+
+      include Enumerable[Step]
+
+      attr_reader resolution: Integer
+      attr_reader steps: Array[Step]
+      attr_reader notation: String
+
+      def initialize: (String notation, ?resolution: Integer) -> void
+      def each: () { (Step) -> void } -> Pattern
+              | () -> Enumerator[Step, Pattern]
+      def []: (Integer index) -> Step?
+      def length: () -> Integer
+      def size: () -> Integer
+      def trigger_indices: () -> Array[Integer]
+      def accented_indices: () -> Array[Integer]
+      def to_a: () -> Array[Step]
+    end
+
+    class NoteSequence
+      class Event
+        attr_reader index: Integer
+        attr_reader token: String
+        attr_reader midi_note: Integer?
+        attr_reader duration_denominator: Integer?
+        attr_reader duration_multiplier: Float
+        attr_reader tie: bool
+
+        def rest?: () -> bool
+        def tie?: () -> bool
+      end
+
+      include Enumerable[Event]
+
+      attr_reader default_octave: Integer
+      attr_reader events: Array[Event]
+      attr_reader notation: String
+
+      def initialize: (String notation, ?default_octave: Integer) -> void
+      def each: () { (Event) -> void } -> NoteSequence
+              | () -> Enumerator[Event, NoteSequence]
+      def []: (Integer index) -> Event?
+      def length: () -> Integer
+      def size: () -> Integer
+      def midi_notes: () -> Array[Integer?]
+      def note_events: () -> Array[Event]
+    end
+
+    class Track
+      attr_reader name: Symbol
+      attr_reader pattern: Pattern?
+      attr_reader note_sequence: NoteSequence?
+      attr_reader chord_progression: Array[untyped]?
+      attr_reader waveform: Symbol
+      attr_reader gain_db: Float
+      attr_reader pan_position: Float
+      attr_reader envelope: DSP::Envelope?
+      attr_reader effects: Array[untyped]
+      attr_reader pattern_resolution: Integer
+      attr_reader note_resolution: Integer
+      attr_reader default_octave: Integer
+      attr_reader key_root: Symbol?
+      attr_reader scale: Symbol?
+      attr_reader chord_voicing: Symbol
+      attr_reader synth_options: Hash[Symbol, untyped]
+
+      def self.parse_chords: (String | Array[untyped] chords, ?default_octave: Integer) -> Array[untyped]
+      def self.parse_chord_token: (String token, default_octave: Integer) -> untyped
+      def self.apply_chord_inversion: (Array[Integer] midi_notes, String bass_name, Integer root_midi, Integer default_octave) -> Array[Integer]
+      def self.apply_chord_voicing: (Array[Integer] midi_notes, Symbol voicing) -> Array[Integer]
+      def self.quantize_midi_note: (Integer midi_note, key: Symbol, scale: Symbol) -> Integer
+      def initialize: (String | Symbol name, **untyped options) -> void
+      def with_pattern: (String | Pattern pattern) -> Track
+      def with_notes: (String | NoteSequence notes, ?default_octave: Integer) -> Track
+      def with_chords: (String | Array[untyped] chords, ?default_octave: Integer) -> Track
+      def with_key: (String | Symbol key, ?scale: String | Symbol) -> Track
+      def with_chord_voicing: (String | Symbol voicing) -> Track
+      def with_synth: (String | Symbol waveform) -> Track
+      def with_gain: (Numeric db) -> Track
+      def with_pan: (Numeric position) -> Track
+      def with_envelope: (DSP::Envelope envelope) -> Track
+      def with_effects: (Array[untyped] effects) -> Track
+      def event_sources?: () -> bool
+      def pattern?: () -> bool
+      def notes?: () -> bool
+      def chords?: () -> bool
+      def effects?: () -> bool
+      def copy: (**untyped overrides) -> Track
+      def parse_chords: (String | Array[untyped] chords) -> Array[untyped]
+      def quantize_midi_note: (Integer midi_note) -> Integer
+    end
+
+    class Engine
+      attr_reader tempo: Float
+      attr_reader format: Core::Format
+      attr_reader beats_per_bar: Integer
+      attr_reader swing: Float
+
+      def initialize: (tempo: Numeric, ?format: Core::Format, ?beats_per_bar: Integer, ?swing: Numeric) -> void
+      def seconds_per_beat: () -> Float
+      def bar_duration_seconds: () -> Float
+      def step_duration_seconds: (Integer resolution) -> Float
+      def step_start_seconds: (Integer index, Integer resolution) -> Float
+      def step_duration_at: (Integer index, Integer resolution) -> Float
+      def expand_pattern_step: (Pattern::Step step, start_time: Numeric, duration: Numeric) -> Array[Hash[Symbol, untyped]]
+      def timeline_for_track: (Track track, bars: Integer, ?start_bar: Integer, ?start_time: Numeric?) -> Array[Hash[Symbol, untyped]]
+      def build_timeline: (tracks: Array[Track], ?arrangement: Array[Hash[Symbol, untyped]]?, ?default_bars: Integer) -> Array[Hash[Symbol, untyped]]
+      def render: (tracks: Array[Track], ?arrangement: Array[Hash[Symbol, untyped]]?, ?default_bars: Integer) -> Audio
+    end
+  end
+end